Problem: Once upon a time in a kingdom far, far away… Okay, let’s start at the point where Ivan the Fool met Gorynych the Dragon. Ivan took out his magic sword and the battle began. First Gorynych had h heads and t tails. With each strike of the sword Ivan can either cut off several heads (from 1 to n, but not more than Gorynych has at the moment), or several tails (from 1 to m, but not more than Gorynych has at the moment). At the same time, horrible though it seems, Gorynych the Dragon can also grow new heads and tails. And the number of growing heads and tails is determined uniquely by the number of heads or tails cut by the current strike. When the total number of heads and tails exceeds R, Gorynych the Dragon strikes its final blow and destroys Ivan the Fool. That’s why Ivan aims to cut off all the dragon’s heads and tails as quickly as possible and win. The events can also develop in a third way: neither of the opponents can win over the other one and they will continue fighting forever.

The tale goes like this; easy to say, hard to do. Your task is to write a program that will determine the battle’s outcome. Consider that Ivan strikes consecutively. After each blow Gorynych grows a number of new heads and tails depending on the number of cut ones. Gorynych the Dragon is defeated if after the blow he loses all his heads and tails and can’t grow new ones. Ivan fights in the optimal way (fools are lucky), i.e. 

  * if Ivan can win, he wins having struck the least number of blows; 
  * if it is impossible to defeat Gorynych, but is possible to resist him for an infinitely long period of time, then that’s the strategy Ivan chooses; 
  * if Gorynych wins in any case, Ivan aims to resist him for as long as possible. 

Input

The first line contains three integers h, t and R (0 ≤ h, t, R ≤ 200, 0 < h + t ≤ R) which represent the initial numbers of Gorynych’s heads and tails and the largest total number of heads and tails with which Gorynych the Dragon does not yet attack. The next line contains integer n (1 ≤ n ≤ 200). The next n contain pairs of non-negative numbers "hi ti" which represent the number of heads and the number of tails correspondingly, that will grow if Gorynych has i heads (1 ≤ i ≤ n) cut. The next line contains an integer m (1 ≤ m ≤ 200) and then — the description of Gorynych’s behavior when his tails are cut off in the format identical to the one described above. All the numbers in the input file do not exceed 200. 

Output

Print "Ivan" (without quotes) in the first line if Ivan wins, or "Zmey" (that means a dragon in Russian) if Gorynych the Dragon wins. In the second line print a single integer which represents the number of blows Ivan makes. If the battle will continue forever, print in the first line "Draw".

Examples

Input

2 2 4
2
1 0
0 1
3
0 1
0 1
0 0


Output

Ivan
2


Input

2 2 4
1
0 1
1
1 0


Output

Draw


Input

2 2 5
1
1 1
1
3 0


Output

Zmey
2

Solution (in JAVA):

Solution:
//package round45;

import java.io.PrintWriter;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Scanner;

public class E2 {
	Scanner in;
	PrintWriter out;
	String INPUT = "";
	
	int[] rhh, rht, rth, rtt;
	int n, m, R, S;
	BitSet gvisited;
	BitSet[] ig;
	BitSet exc;
	
	void dfs(int cur)
	{
		gvisited.set(cur);
		int hh = cur / S;
		int tt = cur % S;
		for(int i = 0;i < n && i + 1 <= hh;i++){
			int nh = hh - (i + 1) + rhh[i];
			int nt = tt + rht[i];
			if(nh + nt <= R){
				if(ig[nh*S+nt] == null)ig[nh*S+nt] = new BitSet();
				ig[nh * S + nt].set(cur);
			}else{
				exc.set(cur);
			}
			if(nh + nt <= R && !gvisited.get(nh * S + nt)){
				dfs(nh * S + nt);
			}
		}
		for(int i = 0;i < m && i + 1 <= tt;i++){
			int nh = hh + rth[i];
			int nt = tt - (i + 1) + rtt[i];
			if(nh + nt <= R){
				if(ig[nh*S+nt] == null)ig[nh*S+nt] = new BitSet();
				ig[nh * S + nt].set(cur);
			}else{
				exc.set(cur);
			}
			if(nh + nt <= R && !gvisited.get(nh * S + nt)){
				dfs(nh * S + nt);
			}
		}
	}
	
	void solve()
	{
		int h = ni();
		int t = ni();
		R = ni();
		S = R + 1;
		n = ni();
		rhh = new int[n];
		rht = new int[n];
		for(int i = 0;i < n;i++){
			rhh[i] = ni();
			rht[i] = ni();
		}
		
		m = ni();
		rth = new int[m];
		rtt = new int[m];
		for(int i = 0;i < m;i++){
			rth[i] = ni();
			rtt[i] = ni();
		}
		
		BitSet visited = new BitSet();
		BitSet q = new BitSet();
		q.set(h * S + t);
		int turn = 1;
		// BFS. (h,t)→(0,0)の最短路探索
		while(!q.isEmpty()){
			visited.or(q);
			BitSet nq = new BitSet();
			for(int cur = q.nextSetBit(0);cur != -1;cur = q.nextSetBit(cur+1)){
				int hh = cur / S;
				int tt = cur % S;
				for(int i = 0;i < n && i + 1 <= hh;i++){
					int nh = hh - (i + 1) + rhh[i];
					int nt = tt + rht[i];
					if(nh == 0 && nt == 0){
						out.println("Ivan");
						out.println(turn);
						return;
					}
					if(nh + nt <= R && !visited.get(nh * S + nt)){
						nq.set(nh * S + nt);
					}
				}
				for(int i = 0;i < m && i + 1 <= tt;i++){
					int nh = hh + rth[i];
					int nt = tt - (i + 1) + rtt[i];
					if(nh == 0 && nt == 0){
						out.println("Ivan");
						out.println(turn);
						return;
					}
					if(nh + nt <= R && !visited.get(nh * S + nt)){
						nq.set(nh * S + nt);
					}
				}
			}
			q = nq;
			
			turn++;
		}
		
		// BFS(h,t)→外への最長路探索
		gvisited = new BitSet();
		ig = new BitSet[S*S];
//		for(int i = 0;i < S;i++){
//			for(int j = 0;i + j < S;j++){
//				ig[i*S+j] = new BitSet();
//			}
//		}
		exc = new BitSet();
		dfs(h * S + t); // 逆グラフの作成
		if(ig[h * S + t] != null){
			out.println("Draw");
			return;
		}
		
		int[] qt = new int[S*S];
		int pp = 0;
		int qq = 0;
		qt[qq++] = h * S + t;
		for(;pp < qq;pp++){
			int cur = qt[pp];
			int hh = cur / S;
			int tt = cur % S;
			for(int i = 0;i < n && i + 1 <= hh;i++){
				int nh = hh - (i + 1) + rhh[i];
				int nt = tt + rht[i];
				if(nh + nt <= R){
					if(ig[nh * S + nt] == null)continue;
					ig[nh * S + nt].clear(cur);
					if(ig[nh * S + nt].isEmpty()){
						ig[nh * S + nt] = null;
						qt[qq++] = nh * S + nt;
					}
				}
			}
			for(int i = 0;i < m && i + 1 <= tt;i++){
				int nh = hh + rth[i];
				int nt = tt - (i + 1) + rtt[i];
				if(nh + nt <= R){
					if(ig[nh * S + nt] == null)continue;
					ig[nh * S + nt].clear(cur);
					if(ig[nh * S + nt].isEmpty()){
						ig[nh * S + nt] = null;
						qt[qq++] = nh * S + nt;
					}
				}
			}
		}
		for(int i = 0;i < S;i++){
			for(int j = 0;i + j < S;j++){
				if(ig[i*S+j] != null && !ig[i*S+j].isEmpty()){
					out.println("Draw");
					return;
				}
			}
		}
		int[] iqt = new int[S*S];
		Arrays.fill(iqt, -1);
		for(int i = 0;i < qq;i++){
			iqt[qt[i]] = i;
		}
		
		int[] dp = new int[qq];
		dp[0] = 1;
		int max = 1;
		for(int l = 0;l < qq;l++){
			int cur = qt[l];
			int hh = cur / S;
			int tt = cur % S;
			for(int i = 0;i < n && i + 1 <= hh;i++){
				int nh = hh - (i + 1) + rhh[i];
				int nt = tt + rht[i];
				if(nh + nt <= R){
					int j = nh*S+nt;
					dp[iqt[j]] = Math.max(dp[iqt[j]], dp[l] + 1);
				}else{
					max = Math.max(max, dp[l]);
				}
			}
			for(int i = 0;i < m && i + 1 <= tt;i++){
				int nh = hh + rth[i];
				int nt = tt - (i + 1) + rtt[i];
				if(nh + nt <= R){
					int j = nh*S+nt;
					dp[iqt[j]] = Math.max(dp[iqt[j]], dp[l] + 1);
				}else{
					max = Math.max(max, dp[l]);
				}
			}
//			for(int j = g[qt[i]].nextSetBit(0);j != -1;j = g[qt[i]].nextSetBit(j+1)){
//				dp[iqt[j]] = Math.max(dp[iqt[j]], dp[i] + 1);
//			}
//			if(exc.get(cur)){
//				max = Math.max(max, dp[l]);
//			}
		}
		out.println("Zmey");
		out.println(max);
	}
	
	void run() throws Exception
	{
		in = INPUT.isEmpty() ? new Scanner(System.in) : new Scanner(INPUT);
		out = new PrintWriter(System.out);

		solve();
		out.flush();
	}
	
	
	public static void main(String[] args) throws Exception
	{
		new E2().run();
	}
	
	int ni() { return Integer.parseInt(in.next()); }
	void tr(Object... o) { if(INPUT.length() != 0)System.out.println(o.length > 1 || o[0].getClass().isArray() ? Arrays.deepToString(o) : o[0]); }
}