// #pragma GCC target("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
//#pragma GCC -Wnarrowing

//Template {
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
 
//IO templates
//Note: use endl only for interactive problems or to debug segfaults; use newl for other problems
#define newl "\n"
#define fastIO ios::sync_with_stdio(false); cin.tie(nullptr)
#define fileIO(x) ifstream fin((str) x + (str) ".in"); ofstream fout((str) x + (str) ".out");
// void fileIO(string x) {}
#define flush() fflush(stdout)
#define interact(n) fflush(stdout); cin >> n; if (n == -1) return 0
#define testcases int tt; cin >> tt; fun (i, tt) solve();

#define edgeIO(m) fun (i, m) {int a, b; cin >> a >> b; addEdges(a, b);}
#define WeightedEdgeIO(m) fun (i, m) {int a, b, c; cin >> a >> b >> c; addWeightedEdges(a, b, c);}
 
//types
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ordered_multiset tree<int, null_type,less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ll long long
#define int long long
#define ld long double
#define str string
#define boolean bool
#define String string
 
//vector
#define pb push_back
#define append push_back
 
//pairs
#define mp make_pair
#define p2 pair<int, int>
#define p3 pair<int, p2>
#define m3(x, y, z) mp(x, mp(y, z))
#define ich first
#define ni second.first
#define sanshi second.second
 
//For loops
#define ahegao(i, a, b) for (int i = a; i < b; i++)
#define baka(i, b, a) for (int i = b; i > a; i--)
#define fun(i, n) for (int i = 1; i <= (n); (i)++)
#define fon(i, n) for (int i = 0; i < (n); (i)++)
#define fur(i, n) for (auto i : (n))
#define oniichan(i, n) for (auto &i : (n))
 
//Sorts
#define sz(aaa) ((signed) aaa.size())
// #define len(aaa) ((signed) aaa.size())
#define all(a) a.begin(), a.end()
#define Sort(a) sort((a).begin(), (a).end())
#define rSort(a) sort((a).rbegin(), (a).rend())
#define clamp(x, y) (x) = min((int) (x), (int) (y))
#define CLAMP(x, y) (x) = max((int) (x), (int) (y))
 
//Other stuff
#define pqueue priority_queue
#define elif else if
#define addEdges(a, b) adj[a].pb(b); adj[b].pb(a)
#define addWeightedEdges(a, b, c) adj[a].pb(mp(b, c)); adj[b].pb(mp(a, c))
// #define find find_by_order
#define printLength(x) if (x < INF) cout << x << newl; else cout << -1 << newl;
// #define printVector(a) fur (i, a) cout << i << ' '; cout << newl;
void printVector(vector<int> DontUseThisName) {
    fur (i, DontUseThisName) cout << i << ' '; cout << newl;
}
void printVector(vector<p2> DontUseThisName) {
    fur (i, DontUseThisName) cout << i.first << ' ' << i.second << newl; cout << newl;
}
void printVector(vector<vector<int>> DontUseThisName) {
    fur (i, DontUseThisName) printVector(i); cout << newl;
}

void pv(int a) {cout << a << newl;}
void pv(int a, int b) {printVector({a, b});}
void pv(int a, int b, int c) {printVector({a, b, c});}
void pv(int a, int b, int c, int d) {printVector({a, b, c, d});}
void pv(int a, int b, int c, int d, int e) {printVector({a, b, c, d, e});}
// void pv(int a, )
// void printVector(vector<char> DontUseThisName) {
//     fur (i, DontUseThisName) cout << i << ' '; cout << newl;
// }
// void printRange(vector<int>::iterator Left, vector<int>::iterator Right) {
//     for (auto i = Left; i < Right; i++) cout << *i << ' ';
//     cout << newl;
// } 
//Constants
const int MOD =  1e9+7; // 998244353
// const int SMALLMOD = 998244353;
const int INF = 9e10+1337;
const ll EXCEED = 2e18+1337;
const ll GRAVITY = 8e18;

//#define vectorIO(n, MikuBondage) fun (j, n) {int i; cin >> i; MikuBondage.pb(i);}
void vectorIO(int n, vector<int> &DontUseThisName) {
    fun (j, n) {int i; cin >> i; DontUseThisName.pb(i);}
}
//#define vector2IO(n, MikuBondage) fun (j, n) {int i, ii; cin >> i >> ii; MikuBondage.pb(mp(i, ii));}
void vector2IO(int n, vector<p2> &DontUseThisName) {
    fun (j, n) {int i, ii; cin >> i >> ii; DontUseThisName.pb(mp(i, ii));}
}

const int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
#define shortest_path_queue priority_queue<p2, vector<p2>, greater<p2>>
#define printArray(DontUseThisName, NakedLolisGalore, GenshinImpactClimbing) ahegao (j, NakedLolisGalore, GenshinImpactClimbing + 1) cout << DontUseThisName[j] << ' '; cout << newl;
#define print2dArray(SplitComplexProblemsIntoMultipleParts, ScuteSwarm, GenshinImpactClimbing) fun (i, ScuteSwarm) {fun (j, GenshinImpactClimbing) cout << SplitComplexProblemsIntoMultipleParts[i][j] << ' '; cout << newl;}
//}
// const int MAX = 500005;
const int MAX = 200003;
const int MID = 19;
int n, q, a[MAX], leftSparse[MAX][MID], rightSparse[MAX][MID];

int RMQleft(int l, int r) {
    int j = 1;
    while ((1 << j) < r - l + 1) j++;
    j--;
    // cout << l << newl;
    // cout << 1336;
    // pv(j, l, r - (1 << j) + 1);
    return(max(leftSparse[l][j], leftSparse[r - (1 << j) + 1][j]));
}

int RMQright(int l, int r) {
    int j = 1;
    while ((1 << j) < r - l + 1) j++;
    j--;
    // cout << l << newl;
    // cout << 1336;
    // pv(j, l, r - (1 << j) + 1);
    return(max(rightSparse[l][j], rightSparse[r - (1 << j) + 1][j]));
}

void init() {
    fun (i, n) {
        leftSparse[i][0] = a[i+1] - 2 * a[i];
        
    }
    leftSparse[n+1][0] = EXCEED;
    
    fun (i, n) {
        rightSparse[i][0] = 2 * a[i] - a[i-1];
    }
    rightSparse[0][0] = EXCEED;
    // fun (i, n) cout << rightSparse[i][0] << ' ';
    fun (k, 18) {
        // cout << newl;
        fun (i, n - (1 << k) + 1) {
            leftSparse[i][k] = max(leftSparse[i][k-1], leftSparse[i + (1 << (k - 1))][k-1]);
            rightSparse[i][k] = max(rightSparse[i][k-1], rightSparse[i + (1 << (k - 1))][k-1]);
            // cout << rightSparse[i][k] << ' ';
        }
    }
}

int bsLeft(int x, int l, int r) {
    while (l < r) {
        int mid = (l + r + 1) / 2;
        if (a[mid] <= x) {
            l = mid;
        } else {
            r = mid - 1;
        }
    }
    return l;
}

int bsRight(int x, int l, int r) {
    while (l < r) {
        int mid = (l + r) / 2;
        if (a[mid] >= x) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    return l;
}

int bs1(int x, int y, int l, int r) {
    while (l < r) {
        int mid = (l + r) / 2;
        if (RMQleft(x, mid) >= a[y]) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    return l;
}

int bs2(int x, int y, int l, int r) {
    while (l < r) {
        
        int mid = (l + r + 1) / 2;
        // pv(l, mid, r);
        if (RMQright(x, mid) > a[y]) {
            l = mid;
        } else {
            r = mid - 1;
        }
    }
    return l;
}


int query(int x) {
    int l = -1, r = -1, curr = -1, res = 0;
    int lll = bsLeft(x, 0, n+1);
    int rrr = bsRight(x, 0, n+1);
    if (x - a[lll] <= a[rrr] - x) {
        l = lll;
        r = lll;
        curr = lll;
        res = x - a[lll];
    } else {
        l = rrr;
        r = rrr;
        curr = lll;
        res = a[rrr] - x;
    }
    while (true) {
        // pv(l, r, res);
        // cout << endl;
        if (r == n or l == 1) {
            return res + a[n] - a[1];
        }
        if (a[l] - a[l-1] <= a[r+1] - a[r]) {
            int nextL = bs2(l, r+1, 0, l);
            res += a[r] - a[nextL];
            l = nextL;
            // cout << nextL << endl;
            assert(a[l] - a[l-1] > a[r+1] - a[r]);
        } else {
            int nextR = bs1(r, l-1, r, n);
            res += a[nextR] - a[l];
            r = nextR;
            assert(a[l] - a[l-1] <= a[r+1] - a[r]);
        }
    }
    
}

signed main() {
    fastIO;
    cin >> n;
    fun (i, n) cin >> a[i];
    a[0] = -INF;
    a[n+1] = INF;
    init();
    cin >> q;
    fun (i, q) {
        int a; cin >> a;
        cout << query(a) << newl;
    }
}