#define _CRT_SECURE_NO_DEPRECATE
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <ctime>
#include <queue>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <math.h>
#include <stack>
#include <deque>
#include <numeric>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <bitset>

#define all(v) v.begin(),v.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const ld epsylon = 1e-9;
typedef unsigned long ui;

long absMy(long X) {
	if (X < 0) return -X;
	return X;
}

long maxMy(long A, long B) {
	return A>B?A:B;
}
long minMy(long A, long B) { return A<B?A:B;}

struct Pointtt
{
	long x, y;
	bool operator < (const Pointtt & o) {
		return x<o.x;
	}
};

struct compareY {
  bool operator() (Pointtt i,Pointtt j) { return (i.y<j.y);}
} myobject;

long disto(Pointtt p1, Pointtt p2)
{
	return maxMy(absMy(p1.x-p2.x), absMy(p1.y-p2.y));
}

long bruteForce(vector<Pointtt> P, long n)
{
	long mina = 1000000002;
	for (long i = 0; i < n; ++i)
		for (long j = i+1; j < n; ++j)
			if (disto(P[i], P[j]) < mina)
				mina = disto(P[i], P[j]);
	return mina;
}

long stripClosest(vector<Pointtt> strip, long sized, long d)
{
	long mina = d; 
	sort(all(strip), myobject);
	for (long i = 0; i < sized; ++i)
		for (long j = i+1; j < sized && (strip[j].y - strip[i].y) < mina; ++j)
			if (disto(strip[i],strip[j]) < mina)
				mina = disto(strip[i], strip[j]);

	return mina;
}

long closestUtil(vector<Pointtt> P, long n)
{
	if (n <= 3)
		return bruteForce(P, n);
	long mid = n/2;
	Pointtt midPointtt = P[mid];

	vector<Pointtt> F, S;
	for (long i = 0; i < n; ++i) {
		if (i < mid) F.push_back(P[i]);
		else S.push_back(P[i]);
	}
	long dl = closestUtil(F, mid);	
	long dr = closestUtil(S, n-mid);

	long d = minMy(dl, dr);

	vector<Pointtt> strip;
	long j = 0;
	for (long i = 0; i < n; i++)
		if (absMy(P[i].x - midPointtt.x) < d)
		{
			strip[j] = P[i];
			j++;
		}

		return minMy(d, stripClosest(strip, j, d) );
}
long KK;
long closest1(vector<Pointtt> P, long n)
{
	sort(all(P));
	return closestUtil(P, n);
}

int main()
{
	freopen("robot.in","r",stdin);
	freopen("robot.out","w",stdout);
	//program
	long n,m,k;
	cin >> n >> m >> k;
	KK=k;
	vector<Pointtt> PTS;
	for (long i = 0; i < k; ++i) {
		Pointtt s;
		cin >> s.x>>s.y;
		PTS.push_back(s);
	}

	cout << closest1(PTS, k) << endl;
	return 0;
}