#include <cstdio>
#include <algorithm>
#include <map>
#include <vector>

using namespace std;

const int MAXK = 1e5 + 5;
const int TSIZE = (1 << 20);

struct point
{
    int x, y;

    point(int _x, int _y)
    {
        x = _x; y = _y;
    }

    bool operator<(point other) const
    {
        return y < other.y || (y == other.y && x < other.x);
    }
};

int n, m;
int tree[TSIZE], lazy[TSIZE];

void update(int node, int l, int r, int i, int j, int value)
{
    if(lazy[node])
    {
        tree[node] = lazy[node];
        if(l != r)
        {
            lazy[node * 2] = lazy[node];
            lazy[node * 2 + 1] = lazy[node];
        }
        lazy[node] = 0;
    }
    if(r < i || l > j || l > r) return;

    if(r <= j && l >= i)
    {
        tree[node] = value;
        if(l != r)
        {
            lazy[node * 2] = value;
            lazy[node * 2 + 1] = value;
        }
        return;
    }
    int middle = (l + r) / 2;

    update(node * 2, l, middle, i, j, value);
    update(node * 2 + 1, middle + 1, r, i, j, value);
}

int query(int node, int l, int r, int i, int j)
{
    if(i > r || j < l || l > r) return 0;

    if(lazy[node])
    {
        tree[node] = lazy[node];
        if(l != r)
        {
            lazy[node * 2] = lazy[node];
            lazy[node * 2 + 1] = lazy[node];
        }
        lazy[node] = 0;
    }

    if(r <= j && l >= i)
    {
        return tree[node];
    }

    int middle = (l + r) / 2;

    int ans = query(node * 2, l, middle, i, j);
    ans = max(ans, query(node * 2 + 1, middle + 1, r, i, j));

    return ans;
}

map < pair <int, int>, bool> marked;

vector <point> v;

bool updated[MAXK];
int pos[MAXK];

void solve()
{
    scanf("%d %d", &n, &m);

    int q;
    scanf("%d", &q);

    //update(1, 0, MAXM, 2, 5, 1);

    //printf("%d\n", query(1, 0, MAXM, 2, 4));
    while(q--)
    {
        int x, y, x1, y1;
        scanf("%d %d %d %d", &x, &y, &x1, &y1);
        if(x == x1)
        {
            for(int i = y; i <= y1; i++)
            {
                if(!marked[{x, i}])
                {
                    v.push_back(point(x, i));
                    marked[{x, i}] = true;
                }
                //marked[get_ind(x, i)] = true;
            }
        }
        else
        {
            for(int i = x; i <= x1; i++)
            {
                if(!marked[{i, y}])
                {
                    v.push_back(point(i, y));
                    marked[{i, y}] = true;
                }
                //marked[get_ind(i, y)] = true;
            }
        }
    }

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

    int ans = 0;

    for(int i = 0; i < v.size(); i++)
    {
        int nextI = i;
        if(!updated[i])
        {
            while(nextI < v.size() && v[nextI].y == v[i].y)
            {
                int qr = query(1, 1, n, v[nextI].x, v[nextI].x);
                pos[nextI] = qr;
                update(1, 1, n, v[nextI].x, v[nextI].x, v[i].y);
                updated[nextI] = true;
                nextI++;
            }
        }
        //printf("\n");
        int temp = v[i].y - pos[i] - 1;
        //printf("%d %d %d %d\n", v[i].x, v[i].y, temp, qr);
        int tnp = 1;
        int l = 1, r = v[i].x - 1;
        int tAns = 0;
        while(l <= r)
        {
            int middle = (l + r) / 2;
            int co = v[i].y - query(1, 1, n, middle, v[i].x - 1) - 1;
            if(co >= temp)
            {
                tAns = middle;
                r = middle - 1;
            }
            else
            {
                l = middle + 1;
            }
        }
        if(tAns != 0)
        {
            tnp += v[i].x - tAns;
        }
        l = v[i].x + 1; r = n;
        tAns = 0;
        while(l <= r)
        {
            int middle = (l + r) / 2;
            int co = v[i].y - query(1, 1, n, v[i].x + 1, middle) - 1;
            if(co >= temp)
            {
                tAns = middle;
                l = middle + 1;
            }
            else
            {
                r = middle - 1;
            }
        }
        if(tAns != 0)
        {
            tnp += tAns - v[i].x;
        }
        printf("%d %d %d\n", v[i].x, v[i].y, tnp);
        int current = min(tnp, temp);
        ans = max(ans, current);
    }
    printf("%d\n", ans);
}

int main()
{
    solve();

    return 0;
}

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