#pragma GCC optimize("O3,unroll-loops")
#include <bits/stdc++.h>

#define ll long long
#define pb push_back
#define f first
#define s second
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define ios ios_base::sync_with_stdio(false);cin.tie(NULL)
#define ld long double
#define li __int128

using namespace std;

mt19937 rng(time(NULL));

const int N=3e5+5;
struct dsu{
	vector<int> par,siz;
	vector<pair<int,pair<int,int>>> old;
	int cntComp,cntCompsnap;
	bool activeSnap;
	void reset(int n){
		par.resize(n);
		siz.resize(n);
		iota(all(par),0);
		fill(all(siz),1);
		old.clear();
		cntComp=n;
		activeSnap=0;
	}
	void snapshot(){
		old.clear();
		cntCompsnap=cntComp;
		activeSnap=1;
	}
	void goToSnapshot(){
		for(auto p:old){
			par[p.f]=p.s.f;
			siz[p.f]=p.s.s;
		}
		old.clear();
		cntComp=cntCompsnap;
	}
	inline int find(int tr){
		if(tr==par[tr])return tr;
		if(par[tr]==par[par[tr]])return par[tr];
		int d=find(par[par[tr]]);
		if(!activeSnap){
			par[tr]=d;
		}
		return d;
	}
	//inline int find(int tr){return tr==par[tr]?tr:find(par[tr]);}
	inline void merge(int a,int b){
		a=find(a);
		b=find(b);
		if(a==b)return;
		cntComp--;
		if(siz[a]>siz[b])swap(a,b);
		if(activeSnap){
			old.pb({a,{par[a],siz[a]}});
		}
		par[a]=b;
		siz[b]+=siz[a];
	}
}dsu;
vector<int> dx={1,1,1,0,-1,-1,-1,0},dy={1,0,-1,-1,-1,0,1,1};
int main()
{
	ios;
	int n,m,k;
	cin>>n>>m>>k;
	bool mx=0;
	if(n==-1){
		n=75000;
		m=4;
		k=3e5;
		mx=1;
	}
	vector<pair<int,int>> ord;
	int C=4000;
	auto inside=[&](int x,int y){
		return x>=0&&x<n&&y>=0&&y<m;
	};
	auto ind=[&](int x,int y){
		return x*m+y;
	};
	auto onBorder=[&](int x,int y){
		return x==0||y==0||x==n-1||y==m-1;
	};
	if(mx){
		for(int i=0;i<n;i++)for(int j=0;j<m;j++)ord.pb({i,j});
		shuffle(all(ord),rng);
	}
	else{
		for(int i=0;i<k;i++){
			int x,y;
			if(mx){
				x=1;
				y=rng()%m+1;
			}
			else
				cin >> x >> y;
			x--;y--;
			ord.pb({x,y});
		}
	}
	vector<vector<bool>> on(n,vector<bool>(m));
	vector<vector<int>> next(n,vector<int>(m));
	int cnt8=0;
	int cntOn=0;
	auto add=[&](int i,int j){
		for(int kk=0;kk<8;kk++){
			int x=i+dx[kk],y=j+dy[kk];
			if(inside(x,y)){
				next[x][y]++;
				if(next[x][y]==8)cnt8++;
			}
		}
		cntOn++;
	};
	auto sub=[&](int i,int j){
		for(int kk=0;kk<8;kk++){
			int x=i+dx[kk],y=j+dy[kk];
			if(inside(x,y)){
				if(next[x][y]==8)cnt8--;
				next[x][y]--;
			}
		}
		cntOn--;
	};
	vector<bool> ok(k,1);
	int cntDo=0;
	ll resetTime=0;
	int CMin=350,CMax=10000;
	int treba=10;
	for(int i=0;i<k;){
		/*int ost=min(C,k-i);
		int j=i+ost;
		//printf("%i->%i\n",i,j);
		assert(cnt8==0);
		for(int o=i;o<j;o++){
			int x=ord[o].f,y=ord[o].s;
			on[x][y]=1;
			add(x,y);
		}
		C-=47;C=max(C,400);*/
		assert(cnt8==0);
		int j=i;
		bool done=0;
		for(;j-i<CMax&&j<k;j++){
			int x=ord[j].f,y=ord[j].s;
			on[x][y]=1;
			add(x,y);
			if(cnt8!=0&&j==i){
				done=1;
				ok[i]=0;
				on[x][y]=0;
				sub(x,y);
				break;
			}
			if(cnt8>treba&&j-i>CMin){
				j++;
				break;
			}
		}
		if(done){
			i++;
			continue;
		}
		//printf("%i!\n",j-i);
		
		ll st=clock();
		dsu.reset(n*m+1);
		for(int x=0;x<n;x++){
			for(int y=0;y<m;y++){
				if(!on[x][y]){
					if(onBorder(x,y)){
						dsu.merge(ind(x,y),n*m);
					}
					for(int kk=0;kk<4;kk++){
						int xx=x+dx[kk],yy=y+dy[kk];
						if(inside(xx,yy)&&!on[xx][yy]){
							dsu.merge(ind(x,y),ind(xx,yy));
						}
					}
				}
			}
		}
		resetTime+=clock()-st;
		cntDo++;
		//printf("CntComp: %i\n",dsu.cntComp);
		int cntBack=0;
		while(1){
			if(dsu.cntComp-cntOn==1&&cnt8==0){ // everything is ok
				break;
			}
			cntBack++;
			dsu.snapshot();
			for(int o=j-1;o>=i-1;o--){
				assert(o!=i-1);
				int x=ord[o].f,y=ord[o].s;
				assert(on[x][y]);
				on[x][y]=0;
				sub(x,y);
				if(onBorder(x,y)){
					dsu.merge(ind(x,y),n*m);
				}
				for(int kk=0;kk<8;kk++){
					int xx=x+dx[kk],yy=y+dy[kk];
					if(inside(xx,yy)&&!on[xx][yy]){
						dsu.merge(ind(x,y),ind(xx,yy));
					}
				}
				if(dsu.cntComp-cntOn==1&&cnt8==0){
					ok[o]=0;
					dsu.goToSnapshot();
					for(int p=o+1;p<j;p++){
						on[ord[p].f][ord[p].s]=1;
						add(ord[p].f,ord[p].s);
					}
					if(onBorder(x,y)){
						dsu.merge(ind(x,y),n*m);
					}
					for(int kk=0;kk<8;kk++){
						int xx=x+dx[kk],yy=y+dy[kk];
						if(inside(xx,yy)&&!on[xx][yy]){
							dsu.merge(ind(x,y),ind(xx,yy));
						}
					}
					break;
				}
			}
		}
		i=j;
	}
	if(mx)
	printf("%i\n",cntDo),printf("%lld\n",resetTime),printf("C: %i\n",C);
	for(int i=0;i<k;i++){
		printf(ok[i]?"1":"0");
	}
	printf("\n");
	return 0;
}