#define MAX_NM 10000
#define ST ((byte) 'L')
#define DR ((byte) 'R')
#define SZ(nod, tip) ((tip == ST) ? SzL[nod] : SzR[nod])
#define CONT(tip) (*((tip == ST) ? &L : &R))
#define FOLO(nod, tip) ((tip == ST) ? FL[nod] : FR[nod])

#include <fstream>
#include <vector>
#include <queue>
#include <utility>
#include <bitset>
using namespace std;

ifstream fin("cuplaj.in");
ofstream fout("cuplaj.out");

using byte = unsigned char;

int n, m, e, SzL[MAX_NM + 1], SzR[MAX_NM + 1];
vector<int> L[MAX_NM + 1], R[MAX_NM + 1];
bitset<MAX_NM + 1> FL, FR;

// Noduri terminale.
queue<pair<int, byte>> Term;

vector<pair<int, int>> Rasp;

void Init();
void Cupleaza(int nodL, int nodR);

int main()
{
	fin >> n >> m >> e;
	for (int i = 0, u, v; i < e; ++i)
	{
		fin >> u >> v;
		L[u].push_back(v);
		++SzL[u];
		
		R[v].push_back(u);
		++SzR[v];
	}
	
	Init();
	
	bool ok;
	do
	{
	INCEPUT:
		while (!Term.empty())
		{
			int nod  = Term.front().first;
			byte tip = Term.front().second;
			Term.pop();
			
			if (SZ(nod, tip) != 1) { continue; }
			
			for (int vecin : CONT(tip)[nod])
			{
				if (!FOLO(vecin, tip))
				{
					Cupleaza((tip == ST) ? nod : vecin, (tip == DR) ? nod : vecin);
					break;
				}
			}
		}
		
		ok = false;
		for (int nod = 1; nod <= n; ++nod)
		{
			if (SzL[nod] != 0)
			{
				for (int vecin : L[nod])
				{
					if (!FR[vecin])
					{
						Cupleaza(nod, vecin);
						if (!Term.empty())
						{
							goto INCEPUT;
						}
						ok = true;
					}
				}
			}
		}
	}
	while (ok);
	
	fout << Rasp.size() << '\n';
	for (size_t i = 0; i < Rasp.size(); ++i)
	{
		fout << Rasp[i].first << ' ' << Rasp[i].second << '\n';
	}
	
	fin.close();
	fout.close();
	return 0;
}

void Init()
{
	for (int i = 1; i <= n; ++i)
	{
		if (SzL[i] == 1) { Term.emplace(i, ST); }
	}
	for (int i = 1; i <= m; ++i)
	{
		if (SzR[i] == 1) { Term.emplace(i, DR); }
	}
}

void Cupleaza(int nodL, int nodR)
{
	FL[nodL] = true;
	FR[nodR] = true;
	Rasp.emplace_back(nodL, nodR);
	
	for (int vecin : CONT(ST)[nodL])
	{
		if (vecin != nodR)
		{
			--SzR[vecin];
			if (SzR[vecin] == 1)
			{
				Term.emplace(vecin, DR);
			}
		}
	}
	for (int vecin : CONT(DR)[nodR])
	{
		if (vecin != nodL)
		{
			--SzL[vecin];
			if (SzL[vecin] == 1)
			{
				Term.emplace(vecin, ST);
			}
		}
	}
	
	SzL[nodL] = SzR[nodR] = 0;
}