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

using ll = long long;

static const ll INF = (1LL << 62);

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;

    vector<ll> X(N + 2);
    for (int i = 1; i <= N; ++i) cin >> X[i];

    int Q;
    cin >> Q;

    if (N == 1) {
        while (Q--) {
            ll S;
            cin >> S;
            cout << llabs(S - X[1]) << '\n';
        }
        return 0;
    }

    // A[i] = 2*X[i] - X[i-1]   (i = 2..N)
    // B[i] = 2*X[i] - X[i+1]   (i = 1..N-1)
    vector<ll> A(N + 2, -INF), B(N + 2, INF);
    for (int i = 2; i <= N; ++i) A[i] = 2 * X[i] - X[i - 1];
    for (int i = 1; i <= N - 1; ++i) B[i] = 2 * X[i] - X[i + 1];

    int LG = 1;
    while ((1 << LG) <= N + 1) ++LG;

    vector<int> lg(N + 2, 0);
    for (int i = 2; i <= N + 1; ++i) lg[i] = lg[i / 2] + 1;

    // Sparse table max for A
    vector<vector<ll>> stMax(LG, vector<ll>(N + 2, -INF));
    // Sparse table min for B
    vector<vector<ll>> stMin(LG, vector<ll>(N + 2, INF));

    for (int i = 2; i <= N; ++i) stMax[0][i] = A[i];
    for (int i = 1; i <= N - 1; ++i) stMin[0][i] = B[i];

    for (int k = 1; k < LG; ++k) {
        int len = 1 << k;
        int half = len >> 1;

        for (int i = 2; i + len - 1 <= N; ++i) {
            stMax[k][i] = max(stMax[k - 1][i], stMax[k - 1][i + half]);
        }
        for (int i = 1; i + len - 1 <= N - 1; ++i) {
            stMin[k][i] = min(stMin[k - 1][i], stMin[k - 1][i + half]);
        }
    }

    auto getMaxA = [&](int l, int r) -> ll {
        int k = lg[r - l + 1];
        return max(stMax[k][l], stMax[k][r - (1 << k) + 1]);
    };

    auto getMinB = [&](int l, int r) -> ll {
        int k = lg[r - l + 1];
        return min(stMin[k][l], stMin[k][r - (1 << k) + 1]);
    };

    while (Q--) {
        ll S;
        cin >> S;

        // Find nearest point to S, tie -> smaller coordinate
        int pos = lower_bound(X.begin() + 1, X.begin() + N + 1, S) - X.begin();
        int k;

        if (pos == 1) k = 1;
        else if (pos == N + 1) k = N;
        else {
            ll leftDist = S - X[pos - 1];
            ll rightDist = X[pos] - S;
            if (leftDist <= rightDist) k = pos - 1;
            else k = pos;
        }

        ll ans = llabs(S - X[k]);
        int l = k, r = k;

        // side = 0: currently at left endpoint
        // side = 1: currently at right endpoint
        int side = 0;

        while (l > 1 || r < N) {
            bool goLeft;

            if (l == 1) {
                goLeft = false;
            } else if (r == N) {
                goLeft = true;
            } else {
                ll dL, dR;
                if (side == 0) {
                    // currently at X[l]
                    dL = X[l] - X[l - 1];
                    dR = X[r + 1] - X[l];
                } else {
                    // currently at X[r]
                    dL = X[r] - X[l - 1];
                    dR = X[r + 1] - X[r];
                }
                goLeft = (dL <= dR);
            }

            if (goLeft) {
                ll T = X[r + 1];

                int lo = 0, hi = l - 1, best = 0;
                while (lo <= hi) {
                    int mid = (lo + hi) >> 1;
                    bool ok = true;
                    if (mid > 0) {
                        int L = l - mid + 1;
                        int R = l;
                        ok = (getMaxA(L, R) <= T);
                    }
                    if (ok) {
                        best = mid;
                        lo = mid + 1;
                    } else {
                        hi = mid - 1;
                    }
                }

                l -= best;
                ans += X[l + best] - X[l];
                side = 0;
            } else {
                ll T = X[l - 1];

                int lo = 0, hi = N - r, best = 0;
                while (lo <= hi) {
                    int mid = (lo + hi) >> 1;
                    bool ok = true;
                    if (mid > 0) {
                        int L = r;
                        int R = r + mid - 1;
                        ok = (getMinB(L, R) >= T);
                    }
                    if (ok) {
                        best = mid;
                        lo = mid + 1;
                    } else {
                        hi = mid - 1;
                    }
                }

                r += best;
                ans += X[r] - X[r - best];
                side = 1;
            }
        }

        cout << ans << '\n';
    }

    return 0;
}