Problem: Monocarp plays a computer game called "Goblins and Gnomes". In this game, he manages a large underground city of gnomes and defends it from hordes of goblins.

The city consists of n halls and m one-directional tunnels connecting them. The structure of tunnels has the following property: if a goblin leaves any hall, he cannot return to that hall. 

The city will be attacked by k waves of goblins; during the i-th wave, i goblins attack the city. Monocarp's goal is to pass all k waves.

The i-th wave goes as follows: firstly, i goblins appear in some halls of the city and pillage them; at most one goblin appears in each hall. Then, goblins start moving along the tunnels, pillaging all the halls in their path. 

Goblins are very greedy and cunning, so they choose their paths so that no two goblins pass through the same hall. Among all possible attack plans, they choose a plan which allows them to pillage the maximum number of halls. After goblins are done pillaging, they leave the city.

If all halls are pillaged during the wave — Monocarp loses the game. Otherwise, the city is restored. If some hall is pillaged during a wave, goblins are still interested in pillaging it during the next waves.

Before each wave, Monocarp can spend some time preparing to it. Monocarp doesn't have any strict time limits on his preparations (he decides when to call each wave by himself), but the longer he prepares for a wave, the fewer points he gets for passing it. If Monocarp prepares for the i-th wave for t_i minutes, then he gets max(0, x_i - t_i ⋅ y_i) points for passing it (obviously, if he doesn't lose in the process).

While preparing for a wave, Monocarp can block tunnels. He can spend one minute to either block all tunnels leading from some hall or block all tunnels leading to some hall. If Monocarp blocks a tunnel while preparing for a wave, it stays blocked during the next waves as well.

Help Monocarp to defend against all k waves of goblins and get the maximum possible amount of points!

Input

The first line contains three integers n, m and k (2 ≤ n ≤ 50; 0 ≤ m ≤ (n(n - 1))/(2); 1 ≤ k ≤ n - 1) — the number of halls in the city, the number of tunnels and the number of goblin waves, correspondely.

Next m lines describe tunnels. The i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i). It means that the tunnel goes from hall u_i to hall v_i. The structure of tunnels has the following property: if a goblin leaves any hall, he cannot return to that hall. There is at most one tunnel between each pair of halls.

Next k lines describe the scoring system. The i-th line contains two integers x_i and y_i (1 ≤ x_i ≤ 10^9; 1 ≤ y_i ≤ 10^9). If Monocarp prepares for the i-th wave for t_i minutes, then he gets max(0, x_i - t_i ⋅ y_i) points for passing it.

Output

Print the optimal Monocarp's strategy in the following format:

At first, print one integer a (k ≤ a ≤ 2n + k) — the number of actions Monocarp will perform. Next, print actions themselves in the order Monocarp performs them. The i-th action is described by a single integer b_i (-n ≤ b_i ≤ n) using the following format:

  * if b_i > 0 then Monocarp blocks all tunnels going out from the hall b_i; 
  * if b_i < 0 then Monocarp blocks all tunnels going into the hall |b_i|; 
  * if b_i = 0 then Monocarp calls the next goblin wave. 



You can't repeat the same block action b_i several times. Monocarp must survive all waves he calls (goblins shouldn't be able to pillage all halls). Monocarp should call exactly k waves and earn the maximum possible number of points in total.

If there are several optimal strategies — print any of them.

Examples

Input


5 4 4
1 2
2 3
4 3
5 3
100 1
200 5
10 10
100 1


Output


6
-2 -3 0 0 0 0 


Input


5 4 4
1 2
2 3
4 3
5 3
100 100
200 5
10 10
100 1


Output


6
0 -3 0 0 1 0


Input


5 10 1
1 2
1 3
1 4
1 5
5 2
5 3
5 4
4 2
4 3
2 3
100 100


Output


6
1 2 3 4 5 0

Note

In the first example, Monocarp, firstly, block all tunnels going in hall 2, secondly — all tunnels going in hall 3, and after that calls all waves. He spent two minutes to prepare to wave 1, so he gets 98 points for it. He didn't prepare after that, that's why he gets maximum scores for each of next waves (200, 10 and 100). In total, Monocarp earns 408 points.

In the second example, Monocarp calls for the first wave immediately and gets 100 points. Before the second wave he blocks all tunnels going in hall 3. He spent one minute preparing to the wave, so he gets 195 points. Monocarp didn't prepare for the third wave, so he gets 10 points by surviving it. Before the fourth wave he blocks all tunnels going out from hall 1. He spent one minute, so he gets 99 points for the fourth wave. In total, Monocarp earns 404 points.

In the third example, it doesn't matter how many minutes Monocarp will spend before the wave, since he won't get any points for it. That's why he decides to block all tunnels in the city, spending 5 minutes. He survived the wave though without getting any points.

Solution (in CPP):

Solution:
#include<bits/stdc++.h> 
using namespace std;
namespace Ruri{
    #define ms(a,b) memset(a,b,sizeof(a))
    #define repi(i,a,b) for(int i=a,bbb=b;i<=bbb;++i)//attention reg int or reg ll ?
    #define repd(i,a,b) for(int i=a,bbb=b;i>=bbb;--i)
    #define reps(s) for(int i=head[s],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
    #define ce(i,r) i==r?'\n':' '
    #define pb push_back 
    #define all(x) x.begin(),x.end()
    #define gmn(a,b) a=min(a,b)
    #define gmx(a,b) a=max(a,b)
    #define fi first
    #define se second                         
    typedef long long ll;
    typedef unsigned long long ull;
    typedef double db;
    const int infi=1e9;//infi较大，注意涉及inf相加时爆int
    const ll infl=4e18;
    inline ll ceil_div(ll a,ll b){ return (a+b-1)/b; }
    inline ll pos_mod(ll a,ll b){ return (a%b+b)%b; }
    //std::mt19937 rnd(time(0));//std::mt19937_64 rnd(time(0));
}
using namespace Ruri;
namespace Read{
    #define ss(a) scanf("%s",a)
    inline int ri(){ int x; scanf("%d",&x); return x; }
    inline ll rl(){ ll x;  scanf("%lld",&x); return x; }
    inline db rd(){ db x; scanf("%lf",&x); return x; }
}
namespace DeBug{
    #define pr(x) cout<<#x<<": "<<(x)<<endl
    #define pra(x,a,b) cout<<#x<<": "<<endl; \
            repi(i,a,b) cout<<x[i]<<" ";     \
            puts("");   
    #define FR(a) freopen(a,"r",stdin)
    #define FO(a) freopen(a,"w",stdout)
}
using namespace Read;
using namespace DeBug;
const int MAX_N=55;
struct Bipartite_matching{
	int nl,nr;//nl左侧点数，nr右侧点数,1 - nl左侧点nl+1 - nr右侧点
	vector<set<int> >g;
	int match[MAX_N<<1];//0时无匹配，否则表示与哪个点互相匹配
    
    bool ban[MAX_N<<1];
    int used[MAX_N],times;//时间戳优化，避免每次清空used数组
	void init(int l,int r){
		g.resize(l+1);
		nl=l,nr=r,times=0;
		repi(i,1,nl+nr) match[i]=ban[i]=0,used[i]=-1;
	}
	
	void Delete(int u,int dir)
	{
		if(!dir) g[u].clear(),ban[u]=true;
		else{
			ban[u+nl]=true;
			repi(i,1,nl)if(g[i].count(u+nl)) g[i].erase(u+nl);
		} 
	}
	void add_edge(int u,int v){ g[u].insert(v); }

	bool dfs(int u){//看能否给点u找一个匹配点
		used[u]=times;
		for(auto v:g[u]){
			int w=match[v];
			if(!w||(used[w]!=times&&dfs(w))){
				match[u]=v,match[v]=u;
				return true;
			}
		}
		return false;
	}
	int cal()//判是否是完美匹配时若一个点没匹配到可直接返回0不用求完
	{
		repi(i,1,nl+nr) match[i]=0;
		int res=0;
		repi(i,1,nl)if(!match[i]){
			times++;
			if(dfs(i))	res++;
		}
		return res;
	}
}bm;
int n,m,k;
// vector<it>
ll x[55],y[55];
vector<int> erase,ans;
ll dp[55][55];
int pre[55][55];
int main()
{
	n=ri(),m=ri(),k=ri();
	bm.init(n,n);
	repi(i,1,m){
		int u=ri(),v=ri();
		bm.add_edge(u,v+n);
	}
	repi(i,1,k) x[i]=rl(),y[i]=rl();

	int max_matching_start=bm.cal();
	int max_matching_now=max_matching_start;
	while(max_matching_now){
		int res;
		repi(i,1,n){
			if(!bm.ban[i]){
				Bipartite_matching tmp=bm;
				tmp.Delete(i,0);
				if(tmp.cal()<max_matching_now){
					bm.Delete(i,0),res=i; break;
				}
			}
			if(!bm.ban[i+n]){
				Bipartite_matching tmp=bm;
				tmp.Delete(i,1);
				if(tmp.cal()<max_matching_now){
					bm.Delete(i,1),res=-i; break;
				}
			}
		}
		--max_matching_now;
		erase.pb(res);
	}
	reverse(all(erase));
	ms(dp,-1);
	dp[0][max_matching_start]=0;
	repi(i,0,k-1)repi(j,0,max_matching_start)if(~dp[i][j]){
		repi(t,0,j)if(n-t>i+1){
			int delta=j-t;
			ll score=max(0ll,x[i+1]-delta*y[i+1]);
			if(dp[i+1][t]<dp[i][j]+score) dp[i+1][t]=dp[i][j]+score,pre[i+1][t]=j;
		}
	}
	int Left=max_element(dp[k],dp[k]+max_matching_start+1)-dp[k];
	repd(i,k,1){
		ans.pb(0);
		repi(j,Left,pre[i][Left]-1) ans.pb(erase[j]);
		Left=pre[i][Left];
	}
	reverse(all(ans));
	printf("%d\n",(int)ans.size());
	for(auto x:ans) printf("%d ",x);
	puts("");
    return 0;
}