#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <utility>
#include <functional>
#include <iomanip>
#include <typeinfo>
#include <iterator>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <tuple>
#include <map>
#include <set>
#include <numeric>
using namespace std;

#define sortall(container) (sort(container.begin(), container.end()))
#define yn(cond) (cond ? (cout << "Yes" << endl) : (cout << "No" << endl))
#define YN(cond) (cond ? (cout << "YES" << endl) : (cout << "NO" << endl))
#define LLONG_MAX numeric_limits<long long>::max()
#define INT_MAX numeric_limits<int>::max()

typedef long long       ll;
typedef vector<int>     vi;
typedef vector<ll>      vll;
typedef vector<double>  vd;
typedef vector<bool>    vb;
typedef vector<string>  vs;
typedef vector<char>    vc;
typedef pair<int, int>  pii;
typedef pair<ll, ll>    pll;
typedef vector<pii>     vpii;
typedef vector<pll>     vpll;
typedef vector<vll>		vvll;
typedef vector<vi>		vvi;
typedef vector<vb>		vvb;
typedef vector<vc>		vvc;

typedef struct edge_ {
	ll to;
	ll cost; 
} edge;

constexpr double	PI = 3.14159265358979323846;
constexpr ll		INF = 1 << 15;
constexpr ll		MOD = (ll)1e9 + 7;
constexpr double	EPS = 1e-7;
constexpr int		dy4[4] = { 0, 1, 0, -1 };
constexpr int		dx4[4] = { 1, 0, -1, 0 };
constexpr int		dy8[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
constexpr int		dx8[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };

template <int mod>
class modint {
private:
	long long num;
	modint set(int _num) { num = _num % mod; return *this; }

public:
	modint() { num = 0; }
	modint(int num) : num(num % mod) {}

	modint operator =  (const int& x) { return set(x % mod); }
	modint operator +  (const int& x) { return modint<mod>(num + (x % mod)); }
	modint operator -  (const int& x) { return modint<mod>(num - (x % mod)); }
	modint operator *  (const int& x) { return modint<mod>(num * (x % mod)); }
	modint operator /  (const int& x) { return modint<mod>(num / (x % mod)); }
	modint operator += (const int& x) { return set(num + (x % mod)); }
	modint operator -= (const int& x) { return set(num - (x % mod)); }
	modint operator *= (const int& x) { return set(num * (x % mod)); }

	friend ostream& operator << (ostream& os, const modint<mod>& x) {
		os << x.num;
		return os;
	}
};

template<typename T>
istream& operator >> (istream& is, vector<T>& vec) {
	for (T& x : vec) is >> x;
	return is;
}

template<typename T>
ostream& operator << (ostream& os, const vector<T>& vec) {
	for (const T& x : vec) os << x << " ";
	return os;
}

template<typename S, typename T>
istream& operator >> (istream& is, pair<S, T>& p) {
	is >> p.first >> p.second;
	return is;
}

template<typename S, typename T>
ostream& operator << (ostream& os, const pair<S, T>& p) {
	os << p.first << " " << p.second;
	return os;
}

/******************************************************************************/
/**********************         Don't make WA !!         **********************/
/******************************************************************************/

int main()
{
	int A, B, Q;
	cin >> A >> B >> Q;
	vll s(A), t(B), x(Q);
	cin >> s >> t >> x;

	vector<pair<ll, string>> build;
	for (auto ss : s)
		build.push_back(make_pair(ss, "shrine"));
	for (auto tt : t)
		build.push_back(make_pair(tt, "temple"));

	sortall(build);

	vll dist;
	vll shrine_idx;
	vll temple_idx;
	for (int i = 0; i < build.size(); i++) {
		auto b = build[i];
		dist.push_back(b.first);

		if (b.second == "shrine") shrine_idx.push_back(i);
		if (b.second == "temple") temple_idx.push_back(i);
	}

	for (int q = 0; q < Q; q++) {
		ll ans = 0;
		ll start = x[q];

		ll lower_idx = lower_bound(dist.begin(), dist.end(), start) - dist.begin();
		if (lower_idx >= dist.size()) lower_idx = dist.size() - 1;

		ll start_idx1 = lower_idx, start_idx2 = lower_idx - 1;

		ll ans1, ans2;
		ans1 = ans2 = LLONG_MAX;

		if (start_idx1 >= 0) {
			ans1 = abs(start - dist[start_idx1]);
			if (build[start_idx1].second == "shrine") {
				ll neighbor_idx1 = lower_bound(temple_idx.begin(), temple_idx.end(), start_idx1) - temple_idx.begin();
				if (neighbor_idx1 >= temple_idx.size()) neighbor_idx1 = temple_idx.size() - 1;
				ll neighbor_idx2 = neighbor_idx1 - 1;

				ll min_dist1 = abs(dist[temple_idx[neighbor_idx1]] - dist[start_idx1]);
				ll min_dist2 = neighbor_idx2 >= 0 ? abs(dist[temple_idx[neighbor_idx2]] - dist[start_idx1]) : LLONG_MAX;
				ans1 += min(min_dist1, min_dist2);
			}
			else {
				ll neighbor_idx1 = lower_bound(shrine_idx.begin(), shrine_idx.end(), start_idx1) - shrine_idx.begin();
				if (neighbor_idx1 >= shrine_idx.size()) neighbor_idx1 = shrine_idx.size() - 1;
				ll neighbor_idx2 = neighbor_idx1 - 1;

				ll min_dist1 = abs(dist[shrine_idx[neighbor_idx1]] - dist[start_idx1]);
				ll min_dist2 = neighbor_idx2 >= 0 ? abs(dist[shrine_idx[neighbor_idx2]] - dist[start_idx1]) : LLONG_MAX;
				ans1 += min(min_dist1, min_dist2);
			}
		}

		if (start_idx2 >= 0) {
			ans2 = abs(start - dist[start_idx2]);
			if (build[start_idx2].second == "shrine") {
				ll neighbor_idx1 = lower_bound(temple_idx.begin(), temple_idx.end(), start_idx2) - temple_idx.begin();
				if (neighbor_idx1 >= temple_idx.size()) neighbor_idx1 = temple_idx.size() - 1;
				ll neighbor_idx2 = neighbor_idx1 - 1;

				ll min_dist1 = abs(dist[temple_idx[neighbor_idx1]] - dist[start_idx2]);
				ll min_dist2 = neighbor_idx2 >= 0 ? abs(dist[temple_idx[neighbor_idx2]] - dist[start_idx2]) : LLONG_MAX;
				ans2 += min(min_dist1, min_dist2);
			}
			else {
				ll neighbor_idx1 = lower_bound(shrine_idx.begin(), shrine_idx.end(), start_idx2) - shrine_idx.begin();
				if (neighbor_idx1 >= shrine_idx.size()) neighbor_idx1 = shrine_idx.size() - 1;
				ll neighbor_idx2 = neighbor_idx1 - 1;

				ll min_dist1 = abs(dist[shrine_idx[neighbor_idx1]] - dist[start_idx2]);
				ll min_dist2 = neighbor_idx2 >= 0 ? abs(dist[shrine_idx[neighbor_idx2]] - dist[start_idx2]) : LLONG_MAX;
				ans2 += min(min_dist1, min_dist2);
			}
		}

		ans = min(ans1, ans2);
		cout << ans << endl;
	}

	return 0;
}

Measured memory_bytes: 21996