#include<iostream>
#include<vector>
#include<algorithm>
#include<cctype>
#include<utility>
#include<string>
#include<cmath>
#include<cstring>
#include<queue>
#include<map>
#include<queue>

#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef long long int ll;
ll dx[4] = {1,0,0,-1};
ll dy[4] = {0,1,-1,0};

#define ARRAY_MAX 1005
int n,h,w;
ll X1[ARRAY_MAX],X2[ARRAY_MAX],Y1[ARRAY_MAX],Y2[ARRAY_MAX];
ll field[ARRAY_MAX*4][ARRAY_MAX*4];
vector<ll> xs,ys,xunzip,yunzip;
map<ll,ll> xzip,yzip;

void compress(vector<ll>& x,map<ll,ll>& zip,vector<ll>& unzip){

    VSORT(x);
    x.erase(unique(x.begin(),x.end()),x.end());
    unzip.resize(x.size());
    REP(i,x.size()){
        zip[x[i]] = i;
        unzip[i] = x[i];
    }
}


int main(){

    while(cin >> w >> h,w){
        cin >> n;
        xs.clear();
        ys.clear();
        xzip.clear();
        yzip.clear();
        xunzip.clear();
        yunzip.clear();

        REP(i,n){
            cin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
            xs.push_back(X1[i]);
            xs.push_back(X2[i]);
            ys.push_back(Y1[i]);
            ys.push_back(Y2[i]);
            if(X2[i]+1 <= w)xs.push_back(X2[i]+1);
            if(Y2[i]+1 <= h)ys.push_back(Y2[i]+1);
        }
        xs.push_back(0);
        xs.push_back(w);
        ys.push_back(0);
        ys.push_back(h);
        compress(xs,xzip,xunzip);
        compress(ys,yzip,yunzip);

        w = xzip[w];
        h = yzip[h];
        REP(i,h){
            fill(field[i],field[i]+w,0);
        }
        REP(i,n){
            field[yzip[Y1[i]]][xzip[X1[i]]]++;
            field[yzip[Y1[i]]][xzip[X2[i]]]--;
            field[yzip[Y2[i]]][xzip[X1[i]]]--;
            field[yzip[Y2[i]]][xzip[X2[i]]]++;
        }
        
        REP(i,h+1){
            REP(j,w){
                field[i][j+1] += field[i][j];
            }
        }
        REP(i,w+1){
            REP(j,h){
                field[j+1][i] += field[j][i];
            }
        }

        ll ans = 0;
        REP(y,h){
            REP(x,w){

                if(field[y][x]){
                    continue;
                }
                ans++;
                queue<pair<ll,ll> > que;
                que.push(make_pair(y,x));
                while(!que.empty()){

                    ll py = que.front().first;
                    ll px = que.front().second;
                    que.pop();
                    REP(i,4){
                        ll ny = py + dy[i];
                        ll nx = px + dx[i];
                        if(ny < 0 || ny >= h)continue;
                        if(nx < 0 || nx >= w)continue;
                        if(field[ny][nx])continue;
                        que.push(make_pair(ny,nx));
                        field[ny][nx] = 1;
                    }
                }

            }
        }
        cout << ans << endl;
    }

    return 0;
}


Measured memory_bytes: 11100