#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int inf = 1e9 + 7;

array<int, 3> operator+(const array<int, 3> &a, const array<int, 3> &b) {
    return {max(a[0], b[0]), max(a[1], b[1]), max(a[2], b[2])};
}

constexpr array<int, 3> neut = {inf, inf, 2 * inf};

int32_t main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int R, C, n;
    cin >> R >> C >> n;

    vector<pair<int, int>> pt(n);
    vector<int> x(n), y(n);

    for (int i = 0; i < n; ++i) {
        cin >> x[i] >> y[i];
        --x[i], --y[i];
        pt[i] = {x[i], y[i]};
    }

    sort(pt.begin(), pt.end());

    for (int i = 0; i < n; ++i) {
        x[i] = pt[i].first;
        y[i] = pt[i].second;
    }

    vector mx(n + 1, vector<array<int, 3>>(n + 1, neut));

    for (int i = 0; i < n; ++i) {
        multiset<int> sy, diff;
        sy.insert(-1), sy.insert(C);
        diff.insert(C);

        auto ins = [&](int i) {
            if (i == n) {
                return;
            }
            auto it = sy.lower_bound(y[i]);
            int nxt = *it, prv = *prev(it);
            diff.extract(nxt - prv - 1);
            diff.insert(y[i] - prv - 1);
            diff.insert(nxt - y[i] - 1);
            sy.insert(y[i]);
        };

        for (int j = i; j < n; ++j) {
            ins(j);
            int fi = *next(sy.begin());
            int la = *next(sy.rbegin());
            mx[i][j] = {fi, C - la - 1, *diff.rbegin()};
        }
    }

    int ans = R + C;

    auto upd = [&](const array<int, 3> &a, int s) {
        ans = min<ll>(ans, max<ll>(a[0] + a[1], a[2]) + s);
    };

    auto check = [&](int s) -> array<int, 3> {
        array<int, 3> now{};

        auto relax = [&](int i, int j) {
            if (i >= j) {
                now = neut;
            } else {
                now = now + mx[i][j - 1];
            }
        };

        if (x[0] > s || x.back() + s + 1 < R) {
            return neut;
        }

        for (int i = 0, j = 0; i < n; ++i) {
            while (j < n && x[j] - x[i] - 1 <= s) {
                j += 1;
            }
            relax(i, j);
            if (x[i] + s + 1 >= R) {
                break;
            }
        }

        return now;
    };

    auto checku = [&](int u) -> array<int, 3> {
        if (x[0] > u) {
            return neut;
        }

        int j = 0;

        while (j < n && x[j] <= u) {
            j += 1;
        }

        return mx[0][j - 1];
    };

    auto checkd = [&](int d) -> array<int, 3> {
        if (x.back() + d + 1 < R) {
            return neut;
        }

        int j = n;

        while (j > 0 && x[j - 1] + d + 1 >= R) {
            j -= 1;
        }

        return mx[j][n - 1];
    };

    vector<int> us, ds, sums;

    for (int i = 0; i < n; ++i) {
        us.push_back(x[i]);
        ds.push_back(R - x[i] - 1);
        for (int j = 0; j < n; ++j) {
            if (x[j] > x[i]) {
                sums.push_back(x[j] - x[i] - 1);
            }
        }
    }

    us.push_back(0);
    ds.push_back(0);
    sums.push_back(0);
    sort(us.begin(), us.end());
    sort(ds.begin(), ds.end());
    sort(sums.begin(), sums.end());
    us.resize(unique(us.begin(), us.end()) - us.begin());
    ds.resize(unique(ds.begin(), ds.end()) - ds.begin());
    sums.resize(unique(sums.begin(), sums.end()) - sums.begin());

    vector<array<int, 3>> cu, cd, cs;

    for (int u : us) {
        cu.push_back(checku(u));
    }
    for (int d : ds) {
        cd.push_back(checkd(d));
    }
    for (int s : sums) {
        cs.push_back(check(s));
    }

    for (int i = 0; i < size(cu); ++i) {
        for (int j = 0; j < size(cd); ++j) {
            int s = us[i] + ds[j];
//            int is = upper_bound(sums.begin(), sums.end(), s) - sums.begin() - 1;
            upd(cu[i] + cd[j] + check(s), us[i] + ds[j]);
        }
    }

    for (int i = 0; i < size(cs); ++i) {
        for (int j = 0; j < size(cd); ++j) {
            if (sums[i] >= ds[j]) {
                int u = sums[i] - ds[j];
                int iu = upper_bound(us.begin(), us.end(), u) - us.begin() - 1;
                upd(cs[i] + cd[j] + cu[iu], sums[i]);
            }
        }
        for (int j = 0; j < size(cu); ++j) {
            if (sums[i] >= us[j]) {
                int d = sums[i] - us[j];
                int id = upper_bound(ds.begin(), ds.end(), d) - ds.begin() - 1;
                upd(cs[i] + cu[j] + cd[id], sums[i]);
            }
        }
    }

    cout << ans << '\n';

    return 0;
}