#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXQ = 50005;
const int MAXN = 100005;

struct change
{
    int x1, y1, x2, y2;
    change(){}
    change(int x1, int y1, int x2, int y2)
    {
        this -> x1 = x1;
        this -> y1 = y1;
        this -> x2 = x2;
        this -> y2 = y2;
    }
};

int n, m, q;
vector<change> v;

int arr[MAXN], delta = 0;
int dpl[MAXN][2], dpr[MAXN][2];

bool cmp(change x, change y)
{
    return x.y1 < y.y1;
}

void Init()
{
    ios :: sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);

    cin >> n >> m >> q;
    for (int i = 1; i <= q; ++ i)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        v.emplace_back(x1, y1, x2, y2);
    }
}

void update(int d, int le, int ri)
{
    for (int i = le; i <= ri; ++ i)
    {
        arr[i] = min(d, arr[i]);
    }
}

int query(int x)
{
    return arr[x];
}

int main()
{
    Init();

    int idx = 0;
    sort(v.begin(), v.end(), cmp);

    for (int i = 1; i <= n; ++ i)
    {
        arr[i] = 1;
    }

    int ans = 0;
    for (int i = 1; i <= m; ++ i)
    {
        while (idx != v.size() and v[idx].y1 == i)
        {
            if (v[idx].y1 == v[idx].y2) update(0, v[idx].x1, v[idx].x2);
            if (v[idx].x1 == v[idx].x2) update(v[idx].y1 - v[idx].y2, v[idx].x1, v[idx].x2);
            idx++;
        }

    /*    for (int j = 1; j <= n; ++ j)
        {
            cout << arr[j] << ' ';
        }
        cout << endl;*/

        for (int j = 1; j <= n; ++ j)
        {
            if (query(j) <= 0)
            {
                dpl[j][1] = 0;
                continue;
            }
            if (dpl[j - 1][1] != dpl[j][0]) dpl[j][1] = min(dpl[j - 1][1], dpl[j][0]) + 1;
            else
            {
                if (query(j - dpl[j - 1][1]) >= dpl[j - 1][1]) dpl[j][1] = dpl[j - 1][1] + 1;
            }
        }

        for (int j = n; j >= 1; -- j)
        {
            if (query(j) <= 0)
            {
                dpr[j][1] = 0;
                continue;
            }
            if (dpr[j + 1][1] != dpr[j][0]) dpr[j][1] = min(dpr[j + 1][1], dpr[j][0]) + 1;
            else
            {
                if (query(j + dpr[j - 1][1]) >= dpr[j + 1][1]) dpr[j][1] = dpr[j + 1][1] + 1;
            }
        }

        for (int j = 1 ; j <= n; ++ j)
        {
            ans = max(ans, max(dpl[j][1], dpr[j][1]));
            dpl[j][0] = dpl[j][1];
            dpr[j][0] = dpr[j][1];
            dpl[j][1] = dpr[j][1] = 0;
            arr[j]++;
        }

    }

    cout << ans << endl;
    return 0;
}

/*
6 5
4
1 2 1 5
1 4 5 4
5 2 5 2
1 2 1 5
*/