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

#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define FOR(i, a, b) for (int i = (a); i<(b); ++i)
#define RFOR(i, b, a) for (int i = (b)-1; i>=(a); --i)
#define MP make_pair
#define PB push_back
#define F first
#define S second


typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;

#define int LL

struct point
{
	int x, y;
};

pair<point, point> inter(pair<point, point> a, pair<point, point> b)
{
	return {{max(a.F.x, b.F.x), max(a.F.y, b.F.y)}, {min(a.S.x, b.S.x), min(a.S.y, b.S.y)}};
}

vector<point> v;

LL calc(point p)
{
	int n = SZ(v);
	LL ans = 0;
	FOR(i, 0, n)
	{
		ans += abs(v[i].x - p.x) + abs(v[i].y - p.y);
	}	
	return ans;
}

bool bad(point p)
{
	return (p.x & 1) ^ (p.y & 1);
}

LL ter(point a, point b, point di)
{
	if (bad(a))
		a.x += di.x, a.y += di.y;
	if (bad(b))
		b.x -= di.x, b.y -= di.y;
	
	a = {(a.x + a.y) / 2, (a.x - a.y) / 2};	
	b = {(b.x + b.y) / 2, (b.x - b.y) / 2};	
	
	int len = abs(a.x - b.x);
	if (len == 0) return calc(a);
	int l = 0, r = len;
	int dx = (b.x - a.x) / len;
	
	int dy = (b.y - a.y) / len;
	assert(1ll * dy * len == (b.y - a.y));
	
	while (l + 2 < r)
	{
		int d = (r - l) / 3;
		int l2 = l + d;
		int r2 = r - d;
		if (calc({a.x + dx * l2, a.y + dy * l2}) < calc({a.x + dx * r2, a.y + dy * r2}))
			r = r2;
		else
			l = l2;
	}
	LL best = 4e18;
	FOR(L, l, r + 1)
		best = min(best, calc({a.x + dx * L, a.y + dy * L}));
	return best;
}

int32_t main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	
	int n;
	cin >> n;
	v.resize(n);
	VI x(n), y(n);
	FOR(i, 0, n) 
	{
		cin >> v[i].x >> v[i].y;
		x[i] = v[i].x;
		y[i] = v[i].y;
	}

	int d;
	cin >> d;
	
	vector<pair<point, point>> a(n);
	FOR(i, 0, n)
	{
		a[i] = {{x[i] - d + y[i], x[i] - d - y[i]}, {x[i] + d + y[i], x[i] + d - y[i]}};
	}
	pair<point, point> sq = a[0];
	FOR(i, 1, n)
	{
		sq = inter(sq, a[i]);
	}
	if (sq.F.x > sq.S.x || sq.F.y > sq.S.y || (sq.F.x == sq.S.x && sq.F.y == sq.S.y && bad(sq.F)))
	{
		cout << "impossible\n";
		return 0;
	}
	sort(ALL(x));
	sort(ALL(y));
	pair<point, point> b = {{x[n / 2] + y[n / 2], x[n / 2] - y[n / 2]}, {x[n / 2] + y[n / 2], x[n / 2] - y[n / 2]}};
	
	auto res = inter(sq, b);
	if (res.F.x <= res.S.x && res.F.y <= res.S.y)
	{
		point p = {(b.F.x + b.F.y) / 2, ((b.F.x - b.F.y) / 2)};
		cout << calc(p) << endl;
		return 0;
	}
	
	LL ans = 4e18;
	point p1 = {sq.F.x, sq.F.y};
	point p2 = {sq.F.x, sq.S.y};
	point p3 = {sq.S.x, sq.S.y};
	point p4 = {sq.S.x, sq.F.y};
	
	ans = min(ans, ter(p1, p2, {0, 1}));
	ans = min(ans, ter(p2, p3, {1, 0}));
	ans = min(ans, ter(p3, p4, {0, -1}));
	ans = min(ans, ter(p4, p1, {-1, 0}));
	
	cout << ans << endl;	
	
	return 0;
}