// Source: https://usaco.guide/general/io

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <bitset>

#define int long long
#define sz(x) (int) x.size()
#define all(x) x.begin(), x.end()

using namespace std;

const int inf = (int) 1e18;
const int LOG = 25;

// int combine(int x, int y) {
// 	return max(x, y);
// }

vector<vector<int>> stb;
vector<vector<int>> stc;

vector<int> arr, brr, crr;

int N;

int queryb(int &l, int &r, int &idx) {
	int ans = arr[r] - arr[l - 1]; l--; idx = l;

    if (idx == 0) {
		return ans;
	}

    for (int i = LOG; i >= 0; i--) {
		if (idx - (1 << i) >= 0 && stb[i][idx - (1 << i) + 1] <= arr[r + 1]) {
			idx -= (1 << i);
		}
	}

    ans += arr[l] - arr[idx], l = idx;
    return ans;
}

int queryc(int &l, int &r, int &idx) {
	int ans = arr[r + 1] - arr[l]; r++; idx = r;

    if (idx == N - 1) {
		return ans;
	}

    for (int i = LOG; i >= 0; i--) {
		if (idx + (1 << i) < N - 2 && stc[i][idx] > arr[l - 1]) {
			idx += (1 << i);
		}
	}

    ans += arr[idx] - arr[r], r = idx;

    return ans;
}

signed main() {
    cin.tie(0) -> sync_with_stdio(false);

    cin >> N;

	arr.resize(N);

	for (int i = 0; i < N; i++) {
		cin >> arr[i];
	}

	brr.resize(N); crr.resize(N); brr[0] = inf; crr[N - 1] = inf;

	for (int i = 1; i < N; i++) {
		brr[i] = 2 * arr[i] - arr[i - 1];
	}

	for (int i = 0; i < N - 1; i++) {
		crr[i] = 2 * crr[i] - crr[i + 1];
	}

	// sparse table
	stb.resize(LOG + 1); stc.resize(LOG + 1);

	for (int i = 0; i <= LOG; i++) {
		stb[i].resize(N); stc[i].resize(N);
	}

	for (int i = 0; i < N; i++) {
		stb[0][i] = brr[i]; stc[0][i] = crr[i];
	}

	for (int i = 1; i <= LOG; i++) {
		for (int j = 0; j + (1 << i) <= N; j++) {
			stb[i][j] = max(stb[i - 1][j], stb[i - 1][j + (1 << (i - 1))]);
			stc[i][j] = min(stc[i - 1][j], stc[i - 1][j + (1 << (i - 1))]);
		}
	}

	int Q; cin >> Q;

	while (Q--) {
		int start; cin >> start;

		int idx = upper_bound(all(arr), start) - arr.begin();

		int ans = 0;

		if (idx == N) {
			ans = abs(start - arr[N - 1]); idx = N - 1;
		} else if (idx == 0) {
			ans = abs(start - arr[0]);
		} else if (arr[idx] - start < start - arr[idx - 1]) {
			ans = abs(arr[idx] - start);
		} else {
			idx--;
			ans = abs(start - arr[idx]);
		}

		int l = idx, r = idx;

		while (!(l == 0 && r == N - 1)) {
			// cout << l << " " << r << "\n";
			if (l == 0) {
				ans += abs(arr[N - 1] - arr[idx]);
				r = N - 1;
			} else if (r == N - 1) {
				ans += abs(arr[idx] - arr[0]);
				l = 0;
			} else {
				// get the direction you jump in
				if (arr[idx] - arr[l - 1] <= arr[r + 1] - arr[idx]) {
					ans += queryb(l, r, idx);
					// cout << l << " " << r << " " << idx << "\n";
				} else {
					ans += queryc(l, r, idx);
				}
			}
		}

		cout << ans << "\n";
	}
}