#include <bits/stdc++.h>
#define ls(u) tr[0][u].ls
#define rs(u) tr[0][u].rs
#define INF 4000000000
#define N 200005
using namespace std;
typedef long long ll;

int n, tot, rt, Q;
ll x[N];
struct Seg { int ls, rs; ll mx; } tr[2][N*2];

void buildST (int &u, int l, int r, bool tg)
{
    if (!u) { u=++tot; }
    if (l==r) {
        if (!tg) { tr[tg][u].mx=x[l]*2-x[l-1]; }
        else { tr[tg][u].mx=x[r+1]-x[r]*2; }
        return;
    }
    int md=(l+r)/2;
    buildST(ls(u), l, md, tg);
    buildST(rs(u), md+1, r, tg);
    tr[tg][u].mx=max(tr[tg][ls(u)].mx, tr[tg][rs(u)].mx);
}
int qry0 (int u, int l, int r, ll val)
{
    if (l==r) { return l; }
    int md=(l+r)/2;
    if (tr[0][rs(u)].mx<=val) { return qry0(ls(u), l, md, val); }
    else { return qry0(rs(u), md+1, r, val); }
}
int qry1 (int u, int l, int r, ll val)
{
    if (l==r) { return l; }
    int md=(l+r)/2;
    if (tr[1][ls(u)].mx>=val) { return qry1(ls(u), l, md, val); }
    else { return qry1(rs(u), md+1, r, val); }
}

struct Pnt { int u, l, r; };
vector <Pnt> vec;
void dfs (int u, int l, int r, int ql, int qr)
{
    if (l>qr || r<ql) { return; }
    if (ql<=l && r<=qr) { vec.push_back((Pnt){ u, l, r }); return; }
    int md=(l+r)/2;
    dfs(ls(u), l, md, ql, qr);
    dfs(rs(u), md+1, r, ql, qr); 
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d", &n);
    for (int i=1; i<=n; i++) { scanf("%lld", &x[i]); }
    x[0]=-INF; x[n+1]=INF;

    buildST(rt, 1, n, 0);
    buildST(rt, 1, n, 1);
    // x[l]*2-x[l-1] > cr
    // x[r+1]-x[r]*2 >= -cl

    scanf("%d", &Q);

    while (Q--) {
        int pos; scanf("%d", &pos);
        ll ans=0;

        int id=lower_bound(x+1, x+n+1, pos)-x;
        if (id==n+1 || (id!=1 && x[id]-pos>=pos-x[id-1])) { id--; }
        ans+=abs(pos-x[id]);

        // 0 <- 1 ->
        
        bool dir;
        if (x[id]-x[id-1]<=x[id+1]-x[id]) { dir=0; }
        else { dir=1; }

        int idl=id, idr=id;
        while (idl>1 || idr<n) {
            if (idr==n || idl==1) { ans+=x[n]-x[1]; break; }
            vec.clear();
            if (!dir) {
                dfs(rt, 1, n, 1, idl);
                for (int i=vec.size()-1; i>=0; i--) {
                    int u=vec[i].u, l=vec[i].l, r=vec[i].r;
                    if (tr[0][u].mx>x[idr+1]) { idl=qry0(u, l, r, x[idr+1]); break; }
                }
                ans+=x[idr]-x[idl];
            }
            else {
                dfs(rt, 1, n, idr, n);
                for (int i=0; i<(int)vec.size(); i++) {
                    int u=vec[i].u, l=vec[i].l, r=vec[i].r;
                    if (tr[1][u].mx>=-x[idl-1]) { idr=qry1(u, l, r, x[idl-1]); break; } //>=!!!!!!!
                }
                ans+=x[idr]-x[idl];
            }
            dir^=1;
        }
        printf("%lld\n", ans);
    }

    return 0;
}