#pragma GCC target ("avx2")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <bits/stdc++.h>
#define owo(i,a, b) for(int i=(a);i<(b); ++i)
#define uwu(i,a, b) for(int i=(a)-1; i>=(b); --i)
#define senpai push_back
#define ttgl pair<int, int>
#define ayaya cout<<"ayaya~"<<endl
 
using namespace std;
using ll = long long;
using ld = long double;
ll MOD = 998244353;
const ll root = 3;
ll binpow(ll a,ll b){ll res=1;while(b){if(b&1)res=(res*a)%MOD;a=(a*a)%MOD;b>>=1;}return res;}
ll modInv(ll a){return binpow(a, MOD-2);}
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 51;
vector<int> adj[mxN];
int x[mxN], y[mxN];
bool in[mxN], out[mxN];
int n, m, k;
vector<int> res;
ll dp[mxN][mxN];
int opt[mxN];
int req[mxN];
struct Dinic {
	struct Edge { int to, rev; ll flo, cap; };
	int N; vector<vector<Edge>> adj;
	void init(int _N) { N = _N; adj.resize(N); }
	void add(int a, int b, ll cap, ll rcap = 0) {
		adj[a].senpai({b,(int)adj[b].size(),0,cap});
		adj[b].senpai({a,(int)adj[a].size()-1,0,rcap});
	}
	vector<int> lev, ptr;
	bool bfs(int s, int t) {
		lev = ptr = vector<int>(N);
		queue<int> Q({s}); lev[s] = 1;
		while (!Q.empty()) { int u = Q.front(); Q.pop();
		    for(auto e: adj[u]) {
				if (!lev[e.to] && e.cap-e.flo)
					Q.push(e.to), lev[e.to] = lev[u]+1;
			}
		}
		return lev[t];
	}
	ll dfs(int v, int t, ll flo) {
		if (v == t) return flo;
		for (int& i = ptr[v]; i < (adj[v].size()); i++) {
			Edge& e = adj[v][i]; ll dif = e.cap-e.flo;
			if (lev[e.to]!=lev[v]+1||!dif) continue;
			if (ll df = dfs(e.to,t,min(flo,dif))) { 
				e.flo += df; adj[e.to][e.rev].flo -= df;
				return df; }
		}
		return 0;
	}
	ll Flow(int s, int t) {
		ll tot = 0; while (bfs(s,t)) while (ll df = 
			dfs(s,t,numeric_limits<ll>::max())) tot += df;
		return tot;
	}
};
int currmatch() {
    Dinic G;
    G.init(2*n+2);
    owo(i, 0, n) {
        if(in[i]) {
            G.add(i+n, 2*n+1, 1);
        }
        if(out[i]) {
            G.add(2*n, i, 1);
            for(int v: adj[i]) {
                if(in[v]) {
                    G.add(i, v+n, 1);
                }
            }
        }
    }
    return n - G.Flow(2*n, 2*n+1);
}
void solve() {
    cin>>n>>m>>k;
    memset(in, 1, sizeof(in));
    memset(out, 1, sizeof(out));
    owo(i, 0, m) {
        int a, b;
        cin>>a>>b;
        a--; b--;
        adj[a].senpai(b);
    }
    owo(i, 1, k+1) {
        cin>>x[i]>>y[i];
    }
    int f = currmatch();
    int curr = f;
    owo(i, f, k+1) {
        req[i] = i - f + 1;
        owo(j, 0, n) {
            if(in[j]) {
                in[j] = 0;
                if(currmatch() > curr) {
                    res.senpai(-(j+1));
                    curr++;
                    break;
                }
                in[j] = 1;
            }
            if(out[j]) {
                out[j] = 0;
                if(currmatch() > curr) {
                    res.senpai(j+1);
                    curr++;
                    break;
                }
                out[j] = 1;
            }
        }
    }
    memset(dp, NINF, sizeof(dp));
    dp[0][0] = 0;
    owo(i, 1, k+1) {
        owo(j, req[i], k+1) {
            owo(b, 0, j+1) {
                if(dp[i-1][b] + max(0LL, (ll)x[i] - 1LL * y[i] * (j-b)) > dp[i][j]) {
                    dp[i][j] = dp[i-1][b] + max(0LL, (ll)x[i] - 1LL * y[i] * (j-b));
                }
            }
        }
    }
    int cnt = req[k];
    uwu(i, k+1, 1) {
        owo(b, 0, cnt+1) {
            if(dp[i-1][b] + max(0LL, (ll)x[i] - 1LL * y[i] * (cnt-b)) == dp[i][cnt]) {
                opt[i] = cnt-b;
                cnt = b;
            }
        }
    }
    cout<<(res.size() + k)<<"\n";
    int id = 0;
    owo(i, 1, k+1) {
        owo(j, 0, opt[i]) {
            cout<<res[id++]<<" ";
        }
        cout<<"0 ";
    }
}
int main() {
    //freopen("file.in", "r", stdin);
    //freopen("file.out", "w", stdout);
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    cin.tie(0)->sync_with_stdio(0);
    int T = 1;
    owo(tc, 1, T+1) {
        solve();
    }
    return 0;
}