#include <cstdio>
#include <climits>
#include <cstring>
#include <vector>
#include <algorithm>
typedef long long i64;
const int N = 300 + 10;
i64 r, c;
int n;
struct Point {
i64 x, y;
Point() {}
Point(i64 _x, i64 _y): x(_x), y(_y) {}
inline bool operator< (const Point &rhs) const {
return x < rhs.x || (x == rhs.x && y < rhs.y);
}
} p[N];
i64 f[N][N][3];
void init(int l) {
static i64 cur[N];
int tot = 0;
for (int r = l; r <= n; ++r) {
int k = std::lower_bound(cur, cur + tot, p[r].y) - cur;
cur[tot] = p[r].y;
std::rotate(cur + k, cur + tot, cur + tot + 1);
f[l][r][0] = cur[0] - 1;
f[l][r][1] = c - cur[tot++];
for (int i = 1; i < tot; ++i) f[l][r][2] = std::max(f[l][r][2], cur[i] - cur[i - 1] - 1);
}
}
i64 solve(int len) {
i64 res = INT_MAX;
static i64 info[4 * N][3];
static i64 pool[4 * N], temp[4 * N];
for (int i = 1; i <= n; ++i) {
pool[i] = p[i].x;
pool[i + n] = p[i].x + len;
pool[i + 2 * n] = p[i].x + len + 1;
pool[i + 3 * n] = p[i].x + r - 1;
}
std::merge(pool + 1, pool + n + 1, pool + n + 1, pool + 2 * n + 1, temp + 1);
std::merge(pool + 2 * n + 1, pool + 3 * n + 1, pool + 3 * n + 1, pool + 4 * n + 1, temp + 2 * n + 1);
std::merge(temp + 1, temp + 2 * n + 1, temp + 2 * n + 1, temp + 4 * n + 1, pool + 1);
int tot = std::unique(pool + 1, pool + 4 * n + 1) - pool - 1;
for (int i = 1, l = 1, r = 1; i <= tot; ++i) {
while (l <= n && !(p[l].x <= pool[i] && pool[i] <= p[l].x + len)) ++l;
for (r = std::max(l, r); r <= n && p[r].x <= pool[i] && pool[i] <= p[r].x + len;) ++r;
static const i64 INF[3] = {INT_MAX, INT_MAX, INT_MAX};
memcpy(info[i], l > n ? INF : f[l][r - 1], 3 * sizeof(i64));
}
static std::pair<int, i64> q[3][4 * N];
int f[3] = {1, 1, 1}, r[3] = {0, 0, 0};
for (int i = 1, j = 1; i <= tot; ++i) {
i64 s = pool[i];
for (int k = 0; k < 3; ++k) while (f[k] <= r[k] && q[k][f[k]].first < i) ++f[k];
for (; j <= tot && pool[j] <= s + ::r - 1; ++j) {
for (int k = 0; k < 3; ++k) {
while (f[k] <= r[k] && q[k][r[k]].second <= info[j][k]) --r[k];
q[k][++r[k]] = {j, info[j][k]};
}
}
res = std::min(res, std::max(q[0][f[0]].second + q[1][f[1]].second, q[2][f[2]].second));
}
return res;
}
int main() {
scanf("%lld%lld%d", &r, &c, &n);
for (int i = 1; i <= n; ++i) scanf("%lld%lld", &p[i].x, &p[i].y);
std::sort(p + 1, p + n + 1);
std::vector<i64> cur;
for (int i = 1; i <= n; ++i) init(i);
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j)
cur.push_back(std::max(p[i].x - p[j].x - 1, 0LL));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
cur.push_back(p[i].x - 1 + r - p[j].x);
for (int i = 1; i <= n; ++i) cur.push_back(p[i].x - 1), cur.push_back(r - p[i].x);
cur.push_back(0);
std::sort(cur.begin(), cur.end());
cur.erase(std::unique(cur.begin(), cur.end()), cur.end());
i64 ans = INT_MAX;
for (int i = 0; i < cur.size(); ++i) ans = std::min(ans, cur[i] + solve(cur[i]));
printf("%lld\n", ans);
return 0;
}
