#include <bits/stdc++.h>

using namespace std;
using ll = long long;

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

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

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

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

    int ans = R + C;

    auto check = [&](int u, int d)-> ll {
        if (d < 0 || u < 0) {
            assert(false);
        }

        vector<pair<int, int>> events;

        for (int i = 0; i < n; ++i) {
            events.emplace_back(max(int(0), x[i] - u), i);
            events.emplace_back(min(R, x[i] + d + 1), ~i);
        }

        events.push_back({0, n});
        events.push_back({R - 1, n});
        sort(events.begin(), events.end());

        int mxl = 0, mxr = 0, mxs = 0;

        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]);
        };

        auto er = [&](int i) {
            auto me = sy.find(y[i]);
            int nxt = *next(me);
            int prv = *prev(me);
            sy.erase(me);
            diff.extract(nxt - y[i] - 1);
            diff.extract(y[i] - prv - 1);
            diff.insert(nxt - prv - 1);
        };

        bool ok = true;

        for (int i = 0, j = 0; i < size(events); i = j) {
            while (j < size(events) && events[j].first == events[i].first) {
                if (events[j].second >= 0) {
                    ins(events[j].second);
                } else {
                    er(~events[j].second);
                }
                j += 1;
            }

            if (events[i].first < R) {
                if (size(sy) == 2) {
                    ok = false;
                    break;
                }
                int fi = *next(sy.begin());
                int la = *next(sy.rbegin());
                mxl = max(mxl, fi);
                mxr = max(mxr, C - la - 1);
                mxs = max(mxs, *diff.rbegin());
            }
        }

        ll now = 3e10;

        if (ok) {
            now = max<ll>(mxl + mxr, mxs) + u + d;
            ans = min<ll>(ans, now);
        }

        return now;
    };

    for (int k = 0; k < 2; ++k) {
        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);
                }
            }
        }

        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());

        for (int u : us) {
            for (int d : ds) {
                check(u, d);
            }
        }

        for (int u : us) {
            int l = 0, r = int(size(sums)) - 1;

            while (l < size(sums) && sums[l] < u) {
                l++;
            }

            if (l > r) {
                continue;
            }

            check(u, sums[l] - u);
            check(u, sums[r] - u);
            r -= 1;

            if (l > r) {
                continue;
            }

            check(u, sums[r] - u);

            while (l < r) {
                int mid = (l + r) / 2;
                if (check(u, sums[mid] - u) < check(u, sums[mid + 1] - u)) {
                    r = mid;
                } else {
                    l = mid + 1;
                }
            }


            for (int t = max(0, l - 200); t < min(l + 200, int(size(sums))); ++t) {
                if (sums[t] >= u) {
                    check(u, sums[t] - u);
                }
            }
        }

        for (int d : ds) {
            int l = 0, r = int(size(sums)) - 1;

            while (l < size(sums) && sums[l] < d) {
                l++;
            }

            if (l > r) {
                continue;
            }

            check(sums[l] - d, d);
            check(sums[r] - d, d);
            r -= 1;

            if (l > r) {
                continue;
            }

            check(sums[r] - d, d);

            while (l < r) {
                int mid = (l + r) / 2;
                if (check(sums[mid] - d, d) < check(sums[mid + 1] - d, d)) {
                    r = mid;
                } else {
                    l = mid + 1;
                }
            }

            for (int t = max(0, l - 200); t < min(l + 200, int(size(sums))); ++t) {
                if (sums[t] >= d) {
                    check(sums[t] - d, d);
                }
            }
        }

        for (int i = 0; i < n; ++i) {
            swap(x[i], y[i]);
        }
        swap(R, C);
    }

    cout << ans << '\n';

    return 0;
}