#include <bits/stdc++.h>

using namespace std;
using ll = long long;

int 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) -> void {
        vector<pair<int, int>> events;

        for (int i = 0; i < n; ++i) {
            events.emplace_back(max(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());
            }
        }

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

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

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

        for (int s : sums) {
            for (int u : us) {
                if (s >= u) {
                    check(u, s - u);
                }
            }
            for (int d : ds) {
                if (s >= d) {
                    check(s - d, d);
                }
            }
        }

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

    cout << ans << '\n';

    return 0;
}