#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(),(u).end()

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MR = 2e5 + 10;
const int MAXD = 1e7;

LL pref[MR];

LL res[MR];

//LL resB[MR];

PII d[MR];

struct przedzial
{
	LL l, r;
	int lastmn;
}p[MR];

// indeksem dziury bedzie nr prawego przedzialu
// zwiazane jest to z tym, ze przy laczeniu przedzialow prawy idzie do lewego
// i potem w sasiedniej dziurze zmieni sie indeks lewego przedzialu

// struktura do trzymania dziur - wartosc d potrzebna do zamkniecia dziury, wartosc d przy ktorej liczona byla wartosc do zamkniecia przedzialu
// indeksy lewego i prawego przedzialu

struct dziura
{
	int akt, prev, indl, indr;

	dziura() {}

	dziura(int akt, int prev, int indl, int indr)
	{
		this->akt = akt;
		this->prev = prev;
		this->indl = indl;
		this->indr = indr;
	}

	bool operator<(const dziura & other) const
	{
		// przetwarzaj dziury najblizsze do zabicia od lewej do prawej
		if (akt != other.akt)
			return akt < other.akt;
		if(indl != other.indl)
			return indl < other.indl;
		return indr < other.indr;
	}
}dziury[MR];

set<dziura> S;

// globalny mnoznik przez ktory mnozymy roznice miedzy kolejnymi czasami pieczenia
LL gmn;
// szukana suma
LL s;

void kill(int id, int idp, LL lewy = -1);

bool czyKill(int id, int idp, LL lewy)
{
	// wez ind prawego przedzialu
	int rp = dziury[id].indr;
	return lewy > p[rp].l - (d[idp].first - dziury[id].prev);
}

int BS(LL ile, LL sum)
{
	// wylicz po jakim czasie zajmiemy wiecej niz ile pol
	int b = 0, e = MAXD;

	while (b + 1 < e)
	{
		int m = (b + e) / 2;
		if (sum*m + m > ile)
			e = m;
		else
			b = m;
	}

	return e;
}

void upd(int id, int idp)
{
	// wiemy, ze dla czasu pieczenia idp nie zabijemy dziury id
	// mamy tez aktualne info o lewym przedziale
	// trzeba zaktualizowac prawy i moze poprawic wartosci

	// id lewego/prawego przedzialu
	int lp = dziury[id].indl, rp = dziury[id].indr;

	// prawy/lewy koniec lewego/prawego przedzialu
	LL r = p[rp].l, l = p[lp].r;

	int dif = d[idp].first - dziury[id].prev;
	r -= dif;

	// lewy koniec prawego przedzialu tez update
	p[rp].l = r;

	// nie powinnismy zabijac tej dziury
	assert(l <= r);

	// odznacz przy jakim stanie piekarnika sa te wartosci
	dziury[id].prev = d[idp].first;

	// wylicz nowa wartosc do zabicia tej dziury
	int tmp = min(d[idp].first + BS(r - l, p[lp].lastmn), MAXD);

	dziury[id].akt = tmp;
}

set<int> ostatni;

bool killed[MR];

void kill(int id, int idp, LL lewy)
{
	if (killed[id])
		return;
	killed[id] = 1;

	// zabij dziure o indeksie id, przy aktualnym piekarniku idp
	// podlaczamy prawy przedzial do lewego, dzieki temu wszystkie poprzednie dane beda zapisane w prawym ciagle

	// id lewego/prawego przedzialu
	int lp = dziury[id].indl, rp = dziury[id].indr;

	// prawy/lewy koniec lewego/prawego przedzialu
	LL r = p[rp].l, l = p[lp].r;

	// przesun lewy do prawej i prawy do lewej, chyba, ze lewy koniec jest ustalony
	int dif = d[idp].first - dziury[id].prev;
	if (lewy == -1)
		l += p[lp].lastmn * (LL)dif;
	else
		l = lewy;
	r -= dif;

	// skoro zabijamy, to ponizszy assert jest true
	assert(l > r);

	// od razu dodaj konsekwencje wynikajace z zabicia dziury
	// konsekwencje bez pref, bo to nam zalatwia gmn
	s += (p[rp].lastmn + 1) * (l - r);

	// zmodyfikuj globalny mnoznik
	gmn += pref[p[lp].lastmn + p[rp].lastmn + 1] - pref[p[lp].lastmn] - pref[p[rp].lastmn];

	// nie trzeba zmieniac lewej dziury - to wszystko samo sie wyliczy przy jej zabijaniu
	// musisz sie zajac prawa dziura, bo rozrasta Ci sie przedzial w prawo

	// najpierw zrob na niej update dla poprzedniej wartosci piekarnika - zeby powyliczac przedzialy
	// okazuje, sie, ze problemem nie bedzie fakt, ze lewy przedzial bedzie mial lewy koniec dla wiekszej wartosci piekarnika niz prawy
	// to nie ma znaczenia

	// dolacz prawy do lewego
	p[lp].lastmn += p[rp].lastmn + 1;

	// nie modyfikuje lewego konca, ten musi zostac jak jest do poprawnego zabicia lewej dziury
	// prawy koniec jest potrzebny tylko, gdy prawy przedzial nie byl ostatni

	//spr, czy prawy klient nie jest ostatni
	if (rp < *(--ostatni.end()))
	{
		// wylicz id prawej dziury - id przedzialu na prawo od niej
		int idpd = rp + p[rp].lastmn + 1;

		LL expandr = l - r;
		// do expand dodaj jeszcze o ile poszerzyl sie na prawo prawy przedzial
		// wez pod uwage, w ktorym momencie byl policzony prawy koniec prawego przedzialu
		expandr += (LL)(d[idp].first - dziury[idpd].prev)*p[rp].lastmn;
		
		p[lp].r = p[rp].r + expandr;

		// zmodyfikuj jej lewy przedzial
		S.erase(dziury[idpd]);

		dziury[idpd].indl = lp;

		if (czyKill(idpd, idp, p[lp].r))
			kill(idpd, idp, p[lp].r);
		else
		{
			// zrob update
			upd(idpd, idp);
			S.insert(dziury[idpd]);
		}
	}

	// wyrzuc prawy przedzial z seta
	ostatni.erase(rp);

	// wywal dziure z seta
	S.erase(dziury[id]);
}

int main()
{
	int n, m;
	scanf("%d%d", &n, &m);

	FORQ(i, 1, n)
		pref[i] = pref[i - 1] + i;

	// wczytaj klientow i wyznacz przedzialy - dodaj wartownika na pozycji 0
	FORQ(i, 1, n)
	{
		scanf("%lld", &p[i].l);
		//assert(p[i].l <= 1000000000000LL);
		p[i].r = p[i].l;
		p[i].lastmn = 0;
		ostatni.insert(i);
	}

	sort(p,p+n+1, [](const przedzial& p1, const przedzial& p2) -> bool
	{
		return p1.l < p2.l;
	});

	// wyznacz dziury
	FORQ(i, 1, n)
	{
		dziury[i] = dziura((p[i].l - p[i - 1].r < MAXD ? p[i].l - p[i - 1].r + 1 : MAXD), 0, i - 1, i);
		S.insert(dziury[i]);
	}

	// przygotuj piekarniki
	REP(i, m)
	{
		scanf("%d", &d[i].first);
		//assert(d[i].first <= 1000000);
		d[i].second = i;
	}

	// dodaj wartownika z czasem 0
	sort(d, d + m + 1);

	/*if (n*m <= 1e7)
	{
		FORQ(i, 1, m)
		{
			LL s = 0, akt = 0;
			FORQ(j, 1, n)
			{
				akt = max(p[j].l - d[i].first, akt) + d[i].first;
				s += akt - p[j].l;
			}
			resB[d[i].second] = s;
		}
	}*/

	// jedz po piekarnikach i zamykaj kolejne dziury
	FORQ(i, 1, m)
	{
		// dodawaj przemnozona wartosc na poczatku - przed zabiciem wszystkich dziur
		s += gmn*(d[i].first - d[i - 1].first);

		vector<int> toKill;
		for (auto it = S.begin(); it != S.end(); it++)
		{
			if (it->akt > d[i].first)
				break;
			toKill.push_back(it->indr);
		}

		sort(toKill.begin(), toKill.end(), [](const int &i1, const int &i2) -> bool
		{
			return dziury[i1].indl < dziury[i2].indl;
		});

		for (auto ind : toKill)
			kill(ind, i);

		// zapamietaj wynik
		res[d[i].second] = s;
	}

	REP(i, m)
	{
		//printf("ok: %lld jest: %lld\n", resB[i], res[i]);
		printf("%lld\n", res[i]);
	}
	
	return 0;
}