#include <bits/stdc++.h>

using namespace std;
ifstream in("cuplaj.in");
ofstream out("cuplaj.out");
int n,m,col[100],source,dest,level[100],n1,n2;
vector<vector<int>> maxFlow, currFlow;
vector<int> graf[100];
bool color()
{
    memset(col, -1, sizeof(col));
    queue<int> c;
    c.push(0);
    col[0] = 1;
    while(!c.empty())
    {
        int node = c.front();
        c.pop();
        for(auto it:graf[node])
            if(col[it] == -1)
            {
                col[it] = 1-col[node];
                c.push(it);
            }
            else if(col[node] == col[it]){
                cout<<"Nu!"<<endl<<node+1<<' '<<it+1<<' ';
                for(auto aux:graf[node])
                    if(count(graf[it].begin(),graf[it].end(),aux))
                    {
                        cout<<aux+1;
                        return 0;
                    }
            }
    }
    return 1;
}
bool bfs()
{
    queue<int> c;
    memset(level, -1, sizeof(level));
    c.push(source);
    level[source] = 0;
    while(!c.empty())
    {
        int node = c.front();
        c.pop();
        for(auto it:graf[node])
            if(maxFlow[node][it] - currFlow[node][it] > 0 && level[it] == -1)
            {
                level[it] = level[node]+1;
                c.push(it);
                if(it == dest)
                    return 1;
            }
    }
    return 0;
}
int dfs(int i,int flow)
{
    if(i == dest)
        return flow;
    for(auto it:graf[i]){
        if(maxFlow[i][it] - currFlow[i][it] > 0 && level[it] == level[i]+1)
        {
            int aux = dfs(it,min(flow,maxFlow[i][it] - currFlow[i][it]));
            if(aux>0){
                currFlow[i][it] += aux;
                currFlow[it][i] -= aux;
                return aux;
            }
        }
    }
    return 0;
}
int main()
{
    in>>n1>>n2>>m;
    n = n1+n2;
    maxFlow.resize(n+2);
    currFlow.resize(n+2);
    for(int i=0;i<n+2;i++)
        maxFlow[i].resize(n+2), currFlow[i].resize(n+2);
    for(int i=0;i<m;i++)
    {
        int a,b;
        in>>a>>b;
        a--;b--;b+=n1;
        graf[a].push_back(b);
        graf[b].push_back(a);

    }
    if (color())
    {
        for(int node=0;node<n;node++)
            for(auto it:graf[node])
                if(col[node])
                    maxFlow[node][it] = 1;
                else
                    maxFlow[it][node] = 1;
        for(int i=0;i<n;i++)
            if(col[i]){
                maxFlow[n][i] = 1;
                graf[n].push_back(i);
            }
            else{
                maxFlow[i][n+1] = 1;
                graf[i].push_back(n+1);
            }
        source = n;dest = n+1;n = n+2;
        while(bfs())
            dfs(source,100000);
        int ans = 0;
        for(int node=0;node<n-2;node++)
            for(auto it:graf[node])
                if(currFlow[node][it] == 1 && it<n-1)
                    ans++;
        out<<ans<<'\n';
        for(int node=0;node<n-2;node++)
            for(auto it:graf[node])
                if(currFlow[node][it] == 1 && it<n-1)
                    out<<node+1<<' '<<it+1-n1<<'\n';
    }

    return 0;
}