#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fstream>
#include <vector>

#define MAX_SIZE	10001
#define NONE		-1

using namespace std;


bool find_path(int u, vector<int> *neighbors, bool *visited, int *left, int *right)
{
	if (visited[u]) return false;

	visited[u] = true;
	for (vector<int>::iterator it = neighbors[u].begin(); it != neighbors[u].end(); ++it)
	{
		if ( (right[*it] == NONE) || find_path(right[*it], neighbors, visited, left, right))
		{
			left[u] = *it;
			right[*it] = u;
			return true;
		}
	}

	return false;
}


void max_matching(vector<int> *neighbors, int *left, int *right, int m, int n, int &max_pairs)
{
	bool 	visited[MAX_SIZE];
	bool	found_path = true;

	while (found_path)
	{
		found_path = false;
		memset(visited, false, MAX_SIZE*sizeof(bool));

		for (int i = 0; i < n; i++)
		{
			if (left[i] == NONE)
			{
				if (find_path(i, neighbors, visited, left, right))
				{
					found_path = true;
					max_pairs++;
				}
			}
		}
	}
}


int main()
{
	fstream 		f, g;
	int				m, n, e, u, v, max_pairs;
	vector<int>		neighbors[MAX_SIZE];
	int 			left[MAX_SIZE], right[MAX_SIZE];

	f.open("cuplaj.in", ios::in);
	g.open("cuplaj.out", ios::out);

	f >> n >> m >> e;
	for (int i = 0; i < e; i++)
	{
		f >> u >> v;
		neighbors[u - 1].push_back(v - 1);
	}

	memset(left, NONE, MAX_SIZE*sizeof(int));
	memset(right, NONE, MAX_SIZE*sizeof(int));

	max_pairs = 0;
	max_matching(neighbors, left, right, m, n, max_pairs);

	g << max_pairs << endl;
	for (int i = 0; i < n; i++)
	{
		if (left[i] != NONE)
		{
			g << i + 1 << " " << left[i] + 1 << endl;
		}
	}

	g.close();
	f.close();

	return 0;
}