Kicker (table football) is a board game based on football, in which players control the footballers' figures mounted on rods by using bars to get the ball into the opponent's goal. When playing two on two, one player of each team controls the goalkeeper and the full-backs (plays defence), the other player controls the half-backs and forwards (plays attack).Two teams of company Q decided to battle each other. Let's enumerate players from both teams by integers from 1 to 4. The first and second player play in the first team, the third and the fourth one play in the second team. For each of the four players we know their game skills in defence and attack. The defence skill of the i-th player is ai, the attack skill is bi.Before the game, the teams determine how they will play. First the players of the first team decide who will play in the attack, and who will play in the defence. Then the second team players do the same, based on the choice of their opponents.We will define a team's defence as the defence skill of player of the team who plays defence. Similarly, a team's attack is the attack skill of the player of the team who plays attack. We assume that one team is guaranteed to beat the other one, if its defence is strictly greater than the opponent's attack and its attack is strictly greater than the opponent's defence.The teams of company Q know each other's strengths and therefore arrange their teams optimally. Identify the team that is guaranteed to win (if both teams act optimally) or tell that there is no such team.

The input contain the players' description in four lines. The i-th line contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ 100) — the defence and the attack skill of the i-th player, correspondingly.

If the first team can win, print phrase "Team 1" (without the quotes), if the second team can win, print phrase "Team 2" (without the quotes). If no of the teams can definitely win, print "Draw" (without the quotes).

NoteLet consider the first test sample. The first team can definitely win if it will choose the following arrangement: the first player plays attack, the second player plays defence.Consider the second sample. The order of the choosing roles for players makes sense in this sample. As the members of the first team choose first, the members of the second team can beat them (because they know the exact defence value and attack value of the first team).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
class Program
{
static void Main(string[] args)
{
var s=" ";
string[] all;
int[,] a=new int[4,2];
for (int i = 0; i < 4; i++)
{
s=Console.ReadLine();
all = s.Split(' ');
a[i, 0] = Convert.ToInt32(all[0]);
a[i, 1] = Convert.ToInt32(all[1]);
}
String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;
int powProtect11 = 0;
int powAttack11 = 0;
int powProtect21 = 0;
int powAttack21 = 0;
powAttack1 = a[1, 1];
powProtect1 = a[0, 0];
powAttack11 = a[0, 1];
powProtect11 = a[1, 0];

powAttack2=a[3,1];
powProtect2=a[2,0];
powAttack21 = a[2, 1];
powProtect21 = a[3, 0];
if ((((powProtect1 < powAttack2) && (powAttack1 < powProtect2)) || ((powProtect1 < powAttack21) && (powAttack1 < powProtect21))) && (((powProtect11 < powAttack2) && (powAttack11 < powProtect2)) || ((powProtect11 < powAttack21) && (powAttack11 < powProtect21))))
{

Console.WriteLine(win2);
}
else if (((powProtect11 > powAttack2) && (powAttack11 > powProtect2) && (powProtect11 > powAttack21) && (powAttack11 > powProtect21)) || ((powProtect1 > powAttack2) && (powAttack1 > powProtect2) && (powProtect1 > powAttack21) && (powAttack1 > powProtect21)))
{ Console.WriteLine(win1);
}else{
Console.WriteLine(draw);
}

}
}
}

// Submitted by Silithus @ Macau
using System;
using System.IO;
using System.Collections.Generic;
using CCF_XOI;

namespace RCC2014
{
	class QR_C
	{
		private int beat(int a_atk, int a_def, int b_atk, int b_def)
		{
			if (a_atk > b_def && a_def > b_atk) return 1;
			if (b_atk > a_def && b_def > a_atk) return -1;
			return 0;
		}

		public void Solve(XOI xoi)
		{
			int i, j, res, ans;
			int[,] team;
			string[] ans_words = { "Team 2", "Draw", "Team 1" };

			team = new int[4, 2];
			for (i = 0; i < 4; i++)
				for (j = 0; j < 2; j++)
					team[i, j] = xoi.ReadInt();

			for (i = 0, ans = -1999; i <= 1; i++)
			{
				for (j = 2, res = 1999; j <= 3; j++)
					res = Math.Min(res, beat(team[i, 1], team[1 - i, 0], team[j, 1], team[5 - j, 0]));
				ans = Math.Max(ans, res);
			}

			xoi.o.WriteLine(ans_words[ans + 1]);
		}
	}

	class RCC2014_QR
	{
		static void Main(string[] args)
		{
			XOI xoi = new XOI();
			(new QR_C()).Solve(xoi);
		}
	}
}

namespace CCF_XOI
{
	class XOI
	{
		protected StreamReader sr;
		public StreamWriter o;
		protected Queue<string> buf = new Queue<string>();
		public bool EOF = false;

		public XOI()
		{
			this.sr = new StreamReader(Console.OpenStandardInput());
			this.o = new StreamWriter(Console.OpenStandardOutput());
			this.o.AutoFlush = true;
		}

		public XOI(string in_path, string out_path)
		{
			this.sr = new StreamReader(in_path);
			this.o = new StreamWriter(out_path);
			this.o.AutoFlush = true;
		}

		public int ReadInt()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int32.Parse(s);
		}

		public long ReadLong()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int64.Parse(s);
		}

		public double ReadDouble()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Double.Parse(s);
		}

		public string ReadString()
		{
			string s = this.GetNext();
			return (s == null ? null : s);
		}

		public string ReadLine()
		{	// I will ignore current buffer and read a new line
			string s = "";
			while (s == "" && !this.EOF)
			{
				s = sr.ReadLine();
				this.EOF = (s == null);
			}
			return (this.EOF ? null : s);
		}

		protected string GetNext()
		{
			if (buf.Count == 0)
			{
				while (buf.Count == 0 && !this.EOF)
				{
					string s = sr.ReadLine();
					if (s == null)
						this.EOF = true;
					else
						foreach (string ss in s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
							buf.Enqueue(ss);
				}
			}

			return (this.EOF ? null : buf.Dequeue());
		}
	}
}

using System;
using System.IO;
using System.Text;

namespace Kicker
{
    internal class Program
    {
        private static readonly StreamReader reader =
            new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);

        private static readonly StreamWriter writer =
            new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            var tt = new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                string[] ss = reader.ReadLine().Split(' ');
                int a = int.Parse(ss[0]);
                int d = int.Parse(ss[1]);
                tt[i, 0] = a;
                tt[i, 1] = d;
            }

            bool fwin = false;
            int swin = 0;

            for (int i = 0; i < 2; i++)
            {
                int a1 = tt[i, 0];
                int b1 = tt[1 - i, 1];
                int s1 = 0, s2 = 0;
                for (int j = 2; j < 4; j++)
                {
                    int a2 = tt[j, 0];
                    int b2 = tt[5 - j, 1];

                    if (a2 > b1 && b2 > a1)
                        s2++;
                    if (a2 < b1 && b2 < a1)
                        s1++;
                }
                if (s1 == 2)
                    fwin = true;
                if (s2 > 0)
                    swin++;
            }

            if (fwin)
                writer.WriteLine("Team 1");
            else if (swin == 2)
                writer.WriteLine("Team 2");
            else
            {
                writer.WriteLine("Draw");
            }
            writer.Flush();
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Collections.Generic;
using System.Text;

namespace CSharpParser
{
    public class Solution : SolutionBase
    {
        protected override void Solve()
        {
            var a = new int[4];
            var b = new int[4];
            for (var i = 0; i < 4; i++)
            {
                Next(out a[i]);
                Next(out b[i]);
            }
            if ((a[0] > b[2] && b[1] > a[3]) && (a[0] > b[3] && b[1] > a[2]))
                PrintLine("Team 1");
            else if ((a[1] > b[2] && b[0] > a[3]) && (a[1] > b[3] && b[0] > a[2]))
                PrintLine("Team 1");
            else if (((a[0] < b[2] && b[1] < a[3]) || (a[0] < b[3] && b[1] < a[2])) && ((a[1] < b[2] && b[0] < a[3]) || (a[1] < b[3] && b[0] < a[2])))
                PrintLine("Team 2");
            else PrintLine("Draw");
        }
    }

    public static class Algorithm
    {
        public static void Swap<T>(ref T a, ref T b)
        {
            var temp = a;
            a = b;
            b = temp;
        }

        public static T Max<T>(params T[] a)
        {
            var ans = a[0];
            var comp = Comparer<T>.Default;
            for (var i = 1; i < a.Length; i++) ans = comp.Compare(ans, a[i]) >= 0 ? ans : a[i];
            return ans;
        }

        public static T Min<T>(params T[] a)
        {
            var ans = a[0];
            var comp = Comparer<T>.Default;
            for (var i = 1; i < a.Length; i++) ans = comp.Compare(ans, a[i]) <= 0 ? ans : a[i];
            return ans;
        }

        public static void RandomShuffle<T>(T[] a, int index, int length)
        {
            if (index < 0 || length < 0) throw new ArgumentOutOfRangeException();
            var last = index + length;
            if (last > a.Length) throw new ArgumentException();
            var rnd = new Random(DateTime.Now.Millisecond);
            for (var i = index + 1; i < last; i++) Swap(ref a[i], ref a[rnd.Next(index, i + 1)]);
        }

        public static void RandomShuffle<T>(T[] a)
        {
            RandomShuffle(a, 0, a.Length);
        }

        public static bool NextPermutation<T>(T[] a, int index, int length, Comparison<T> compare = null)
        {
            compare = compare ?? Comparer<T>.Default.Compare;
            if (index < 0 || length < 0) throw new ArgumentOutOfRangeException();
            var last = index + length;
            if (last > a.Length) throw new ArgumentException();
            for (var i = last - 1; i > index; i--)
                if (compare(a[i], a[i - 1]) > 0)
                {
                    var j = i + 1;
                    for (; j < last; j++) if (compare(a[j], a[i - 1]) <= 0) break;
                    Swap(ref a[i - 1], ref a[j - 1]);
                    Array.Reverse(a, i, last - i);
                    return true;
                }
            Array.Reverse(a, index, length);
            return false;
        }

        public static bool NextPermutation<T>(T[] a, Comparison<T> compare = null)
        {
            return NextPermutation(a, 0, a.Length, compare);
        }

        public static bool PrevPermutation<T>(T[] a, int index, int length, Comparison<T> compare = null)
        {
            compare = compare ?? Comparer<T>.Default.Compare;
            if (index < 0 || length < 0) throw new ArgumentOutOfRangeException();
            var last = index + length;
            if (last > a.Length) throw new ArgumentException();
            for (var i = last - 1; i > index; i--)
                if (compare(a[i], a[i - 1]) < 0)
                {
                    var j = i + 1;
                    for (; j < last; j++) if (compare(a[j], a[i - 1]) >= 0) break;
                    Swap(ref a[i - 1], ref a[j - 1]);
                    Array.Reverse(a, i, last - i);
                    return true;
                }
            Array.Reverse(a, index, length);
            return false;
        }

        public static bool PrevPermutation<T>(T[] a, Comparison<T> compare = null)
        {
            return PrevPermutation(a, 0, a.Length, compare);
        }

        public static int LowerBound<T>(IList<T> a, int index, int length, T value, Comparison<T> compare = null)
        {
            compare = compare ?? Comparer<T>.Default.Compare;
            if (index < 0 || length < 0) throw new ArgumentOutOfRangeException();
            if (index + length > a.Count) throw new ArgumentException();
            var ans = index;
            var last = index + length;
            var p2 = 1;
            while (p2 <= length) p2 *= 2;
            for (p2 /= 2; p2 > 0; p2 /= 2) if (ans + p2 <= last && compare(a[ans + p2 - 1], value) < 0) ans += p2;
            return ans;
        }

        public static int LowerBound<T>(IList<T> a, T value, Comparison<T> compare = null)
        {
            return LowerBound(a, 0, a.Count, value, compare);
        }

        public static int UpperBound<T>(IList<T> a, int index, int length, T value, Comparison<T> compare = null)
        {
            compare = compare ?? Comparer<T>.Default.Compare;
            if (index < 0 || length < 0) throw new ArgumentOutOfRangeException();
            if (index + length > a.Count) throw new ArgumentException();
            var ans = index;
            var last = index + length;
            var p2 = 1;
            while (p2 <= length) p2 *= 2;
            for (p2 /= 2; p2 > 0; p2 /= 2) if (ans + p2 <= last && compare(a[ans + p2 - 1], value) <= 0) ans += p2;
            return ans;
        }

        public static int UpperBound<T>(IList<T> a, T value, Comparison<T> compare = null)
        {
            return UpperBound(a, 0, a.Count, value, compare);
        }
    }

    public class InStream : IDisposable
    {
        protected readonly TextReader InputStream;
        private string[] _tokens;
        private int _pointer;

        public InStream(TextReader inputStream)
        {
            InputStream = inputStream;
        }

        public InStream(string str)
        {
            InputStream = new StringReader(str);
        }

        public static InStream Freopen(string str)
        {
            return new InStream(new StreamReader(str));
        }

        public string NextLine()
        {
            try
            {
                return InputStream.ReadLine();
            }
            catch (Exception)
            {
                return null;
            }
        }

        private string NextString()
        {
            try
            {
                while (_tokens == null || _pointer >= _tokens.Length)
                {
                    _tokens = NextLine().Split(new[] {' ', '\t'}, StringSplitOptions.RemoveEmptyEntries);
                    _pointer = 0;
                }
                return _tokens[_pointer++];
            }
            catch (Exception)
            {
                return null;
            }
        }

        public bool Next<T>(out T ans)
        {
            var str = NextString();
            if (str == null)
            {
                ans = default(T);
                return false;
            }
            ans = (T) Convert.ChangeType(str, typeof (T));
            return true;
        }

        public void Dispose()
        {
            InputStream.Close();
        }
    }

    public class OutStream : IDisposable
    {
        protected readonly TextWriter OutputStream;

        public OutStream(TextWriter outputStream)
        {
            OutputStream = outputStream;
        }

        public OutStream(StringBuilder strB)
        {
            OutputStream = new StringWriter(strB);
        }

        public static OutStream Freopen(string str)
        {
            return new OutStream(new StreamWriter(str));
        }

        public void Print(string format, params object[] args)
        {
            OutputStream.Write(format, args);
        }

        public void PrintLine(string format, params object[] args)
        {
            Print(format, args);
            OutputStream.WriteLine();
        }

        public void PrintLine()
        {
            OutputStream.WriteLine();
        }

        public void Print<T>(T o)
        {
            OutputStream.Write(o);
        }

        public void PrintLine<T>(T o)
        {
            OutputStream.WriteLine(o);
        }

        public void Dispose()
        {
            OutputStream.Close();
        }
    }

    public abstract class SolutionBase : IDisposable
    {
        private readonly InStream _in;
        private readonly OutStream _out;

        protected SolutionBase()
        {
            //System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
            _in = new InStream(Console.In);
            _out = new OutStream(Console.Out);
        }

        protected string NextLine()
        {
            return _in.NextLine();
        }

        protected bool Next<T>(out T ans)
        {
            return _in.Next(out ans);
        }

        protected T[] NextArray<T>(int length)
        {
            var array = new T[length];
            for (var i = 0; i < length; i++)
                if (!_in.Next(out array[i]))
                    return null;
            return array;
        }

        protected void PrintArray<T>(IList<T> a, string between = " ", string after = "\n", bool printCount = false)
        {
            if (printCount)
                _out.PrintLine(a.Count);
            for (var i = 0; i < a.Count; i++)
                _out.Print("{0}{1}", a[i], i == a.Count - 1 ? after : between);
        }

        public void Print(string format, params object[] args)
        {
            _out.Print(format, args);
        }

        public void PrintLine(string format, params object[] args)
        {
            _out.PrintLine(format, args);
        }

        public void PrintLine()
        {
            _out.PrintLine();
        }

        public void Print<T>(T o)
        {
            _out.Print(o);
        }

        public void PrintLine<T>(T o)
        {
            _out.PrintLine(o);
        }

        public void Dispose()
        {
            _out.Dispose();
        }

        protected abstract void Solve();

        public static void Main()
        {
            using (var p = new Solution()) p.Solve();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;
int powProtect11 = 0;
int powAttack11 = 0;
int powProtect21 = 0;
int powAttack21 = 0;
powAttack1 = a[1, 1];
powProtect1 = a[0, 0];
powAttack11 = a[0, 1];
powProtect11 = a[1, 0];

      powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];
    if ((((powProtect1 < powAttack2) && (powAttack1 < powProtect2)) || ((powProtect1 < powAttack21) && (powAttack1 < powProtect21))) && (((powProtect11 < powAttack2) && (powAttack11 < powProtect2)) || ((powProtect11 < powAttack21) && (powAttack11 < powProtect21))))
    {

Console.WriteLine(win2);
}
    else if (((powProtect11 > powAttack2) && (powAttack11 > powProtect2) && (powProtect11 > powAttack21) && (powAttack11 > powProtect21)) || ((powProtect1 > powAttack2) && (powAttack1 > powProtect2) && (powProtect1 > powAttack21) && (powAttack1 > powProtect21)))
{  Console.WriteLine(win1);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;

public class Solver
{
    public object Solve()
    {
        int[][] a = ReadIntMatrix(4);

        if ((a[0][0] < a[2][1] && a[1][1] < a[3][0] || a[0][0] < a[3][1] && a[1][1] < a[2][0]) &&
            (a[1][0] < a[2][1] && a[0][1] < a[3][0] || a[1][0] < a[3][1] && a[0][1] < a[2][0]))
            return "Team 2";

        if (a[0][0] > a[2][1] && a[1][1] > a[3][0] && a[0][0] > a[3][1] && a[1][1] > a[2][0] ||
            a[1][0] > a[2][1] && a[0][1] > a[3][0] && a[1][0] > a[3][1] && a[0][1] > a[2][0])
            return "Team 1";

        return "Draw";
    }

    #region I/O
    protected static TextReader reader;
    protected static TextWriter writer;

    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = Console.In;
#endif
        writer = Console.Out;
        Solver solver = new Solver();

        try
        {
            object result = solver.Solve();
            if (result != null)
            {
                writer.WriteLine(result);
                //Console.Error.WriteLine(result);
            }
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine(ex);
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read helpers

    static Queue<string> currentLineTokens = new Queue<string>();

    public static string ReadToken()
    {
        if (currentLineTokens.Count == 0)
        {
            currentLineTokens = new Queue<string>(reader.ReadLine().Trim().Split(' '));
        }
        return currentLineTokens.Dequeue();
    }

    public static string[] ReadTokens(bool fromCurrentLine = false)
    {
        string[] split;
        if (fromCurrentLine)
        {
            if (currentLineTokens.Count == 0)
                return new string[0];
            split = currentLineTokens.ToArray();
            currentLineTokens.Clear();
        }
        else
        {
            split = reader.ReadLine().Trim().Split(' ');
        }
        return split;
    }

    public static int ReadInt()
    {
        return int.Parse(ReadToken());
    }

    public static long ReadLong()
    {
        return long.Parse(ReadToken());
    }

    public static double ReadDouble()
    {
        return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
    }

    public static int[] ReadIntArray(bool fromCurrentLine = false)
    {
        string[] tokens = ReadTokens(fromCurrentLine);
        return tokens.Select(int.Parse).ToArray();
    }

    public static long[] ReadLongArray(bool fromCurrentLine = false)
    {
        string[] tokens = ReadTokens(fromCurrentLine);
        return tokens.Select(long.Parse).ToArray();
    }

    public static double[] ReadDoubleArray(bool fromCurrentLine = false)
    {
        string[] tokens = ReadTokens(fromCurrentLine);
        return tokens.Select(double.Parse).ToArray();
    }

    public static int[][] ReadIntMatrix(int numberOfRows)
    {
        int[][] matrix = new int[numberOfRows][];
        for (int i = 0; i < numberOfRows; i++)
            matrix[i] = ReadIntArray();
        return matrix;
    }

    public static string[] ReadLines(int quantity)
    {
        string[] lines = new string[quantity];
        for (int i = 0; i < quantity; i++)
        {
            lines[i] = reader.ReadLine().Trim();
        }
        return lines;
    }

    #endregion
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace C.Kicker
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] D = new int[8];
            for (int i = 0; i < 8; i+=2)
            {
                string str = Console.ReadLine();
                int j;
                for (j = 0; ; j++)
                {
                    if (str[j] == ' ') break;

                }
                D[i] = int.Parse(str.Substring(0,j));
                for (;; j++)
                {
                    if (str[j] != ' ') break;
                }
                D[i + 1] = int.Parse(str.Substring(j));
            }
            int R11 = check(D[0], D[3], D[4], D[7]), R12 = check(D[0], D[3], D[6], D[5]);
            if (R11 == 1 && R12 == 1) Console.WriteLine("Team 1"); else {
                int R21 = check(D[2], D[1], D[4], D[7]), R22 = check(D[2], D[1], D[6], D[5]);
                if (R21 == 1 && R22 == 1) Console.WriteLine("Team 1");
                else if ((R11 == 2 || R12 == 2) && (R21 == 2 || R22 == 2)) Console.WriteLine("Team 2");
                else Console.WriteLine("Draw");
            }

        }
        public static int check(int team1_1, int team1_2, int team2_1,int team2_2)
        {
            if (team1_1 > team2_2 && team1_2 > team2_1)  return 1;
            if (team1_1 < team2_2 && team1_2 < team2_1) return 2;
            return 0;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Threading;
using System.Linq;

class TEST{
	static void Main(){
		Player[] P=new Player[4];
		for(int i=0;i<4;i++){
			var s=Console.ReadLine().Split(' ');
			P[i]=new Player(int.Parse(s[1]),int.Parse(s[0]));
		}

		int[][] Score=new int[2][];
		for(int i=0;i<2;i++)Score[i]=new int[2];

		int off1=0;
		int off2=0;
		int def1=0;
		int def2=0;

		for(int i=0;i<2;i++){
			if(i==0){off1=P[0].Off;def1=P[1].Def;}
			if(i==1){off1=P[1].Off;def1=P[0].Def;}

			for(int j=0;j<2;j++){
				if(j==0){off2=P[2].Off;def2=P[3].Def;}
				if(j==1){off2=P[3].Off;def2=P[2].Def;}

				if(off1>def2 && def1>off2){Score[i][j]=1;continue;}
				if(off1<def2 && def1<off2){Score[i][j]=2;continue;}
				Score[i][j]=3;
			}
		}
		bool chk1=false;
		for(int i=0;i<2;i++){
			if(Score[i][0]==1 &&Score[i][1]==1)chk1=true;
		}

		bool chk2=true;
		for(int i=0;i<2;i++){
			if(Score[i][0]!=2 &&Score[i][1]!=2)chk2=false;
		}

		Console.WriteLine(chk1?"Team 1":(chk2?"Team 2":"Draw"));

	}
}

struct Player{
	public int Off;
	public int Def;
	public Player(int o,int d){
		Off=o;Def=d;
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;

namespace Algorithm
{
    class Solver
    {
        Player[] a = new Player[4];

        public void Run()
        {
            for (int i = 0; i < 4; i++)
            {
                string[] tokens = cin.ReadLine().Split();
                int x = int.Parse(tokens[0]);
                int y = int.Parse(tokens[1]);
                a[i] = new Player(x, y);
            }

            if (can_win(a[0].Defence, a[1].Attak, a[2].Defence, a[3].Attak) &&
                can_win(a[0].Defence, a[1].Attak, a[3].Defence, a[2].Attak))
            {
                cout.WriteLine("Team 1");
                return;
            }
            if (can_win(a[1].Defence, a[0].Attak, a[2].Defence, a[3].Attak) &&
                can_win(a[1].Defence, a[0].Attak, a[3].Defence, a[2].Attak))
            {
                cout.WriteLine("Team 1");
                return;
            }

            int cnt = 0;
            if (can_win(a[2].Defence, a[3].Attak, a[0].Defence, a[1].Attak) ||
               can_win(a[3].Defence, a[2].Attak, a[0].Defence, a[1].Attak)) cnt++;
            if (can_win(a[2].Defence, a[3].Attak, a[1].Defence, a[0].Attak) ||
                can_win(a[3].Defence, a[2].Attak, a[1].Defence, a[0].Attak)) cnt++;

            if (cnt == 2)
                cout.WriteLine("Team 2");
            else
                cout.WriteLine("Draw");
        }

        bool can_win(int a, int b, int c, int d)
        {
            if (a > d && b > c) return true;
            return false;
        }

        void Swap(ref int a, ref int b)
        {
            int tmp = a;
            a = b;
            b = tmp;
        }

        public StreamReader cin = null;
        public StreamWriter cout = null;
    }

    class Player
    {
        public Player() { }
        public Player(int _a, int _d)
        {
            this.Attak = _a;
            this.Defence = _d;
        }
        public int Attak;
        public int Defence;
    }

    class Program
    {
        public static void Main(string[] args)
        {
            Solver task = new Solver();
#if DEBUG
            task.cin = new StreamReader("input.txt");
            task.cout = new StreamWriter("output.txt");
#else
            task.cin = new StreamReader(Console.OpenStandardInput());
            task.cout = new StreamWriter(Console.OpenStandardOutput());
#endif
            task.cout.AutoFlush = true;
            task.Run();
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace AcmSolution
{
    public class Program
    {
        public static void Main(string[] args)
        {
#if !ACM_HOME
            Do();
#else
            var tmp = Console.In;
            //Console.SetIn(new StreamReader("a.txt"));
            while (Console.In.Peek() > 0)
            {
                Do();
                Console.WriteLine(Console.ReadLine());
            }
            Console.In.Close();
            Console.SetIn(tmp);
#endif
            Console.ReadLine();
        }

        private static void Do()
        {
            var s = new Scanner();
            int a1 = s.nextInt(), a2 = s.nextInt();
            int b1 = s.nextInt(), b2 = s.nextInt();
            int c1 = s.nextInt(), c2 = s.nextInt();
            int d1 = s.nextInt(), d2 = s.nextInt();

            int win1 = Win(a1, b2, c1, c2, d1, d2);
            int win2 = Win(b1, a2, c1, c2, d1, d2);
            if (win1 == 1 || win2 == 1)
                Console.WriteLine("Team 1");
            else if (win1 == 2 && win2 == 2)
                Console.WriteLine("Team 2");
            else
                Console.WriteLine("Draw");
        }

        private static int Win(int napadenie, int zashita, int c1, int c2, int d1, int d2)
        {
            if (napadenie > c2 && napadenie > d2 && zashita > c1 && zashita > d1)
                return 1;

            if ((napadenie < c2 && zashita < d1) || (napadenie < d2 && zashita < c1))
                return 2;

            return 0;
        }

        private static void Assert(bool b)
        {
            if (!b) throw new Exception();
        }

        private static void WriteDouble<T>(T d)
        {
            Console.WriteLine(string.Format("{0:0.00000000000000}", d).Replace(',', '.'));
        }
    }

    class Scanner
    {
        string[] s;
        int i;

        public Scanner()
        {
            s = new string[0];
            i = 0;
        }

        public string next()
        {
            if (i < s.Length) return s[i++];
            s = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            i = 0;
            return s[i++];
        }

        public int nextInt()
        {
            return int.Parse(next());
        }

        public char nextChar()
        {
            return char.Parse(next());
        }

        public long nextLong()
        {
            return long.Parse(next());
        }

        public double nextDouble()
        {
            return double.Parse(next());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ContestA
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] pass1 = Console.ReadLine().Split(' ');
            string[] pass2 = Console.ReadLine().Split(' ');
            string[] pass3 = Console.ReadLine().Split(' ');
            string[] pass4 = Console.ReadLine().Split(' ');

            int a1 = Convert.ToInt32(pass1[0]);
            int b1 = Convert.ToInt32(pass1[1]);
            int a2 = Convert.ToInt32(pass2[0]);
            int b2 = Convert.ToInt32(pass2[1]);
            int a3 = Convert.ToInt32(pass3[0]);
            int b3 = Convert.ToInt32(pass3[1]);
            int a4 = Convert.ToInt32(pass4[0]);
            int b4 = Convert.ToInt32(pass4[1]);

            // АСАБЫЙ СЛУЧАЙ - ОДИНАКОВО ИГРОКИ
            bool svinka = false;
            if (a1 == a3 || a2 == a4 || b1 == b3 || b2 == b4)
                svinka = true;

            // ВИГРЫШ ВТОРОГА
            if ((a3 > a1 && b4 > b2) || (a4 > a1 && b3 > b2))
                if ((a3 > a2 && b4 > b1) || (a4 > a2 && b3 > b1))
                {
                    Console.WriteLine("Team 2");

                    return;
                }

            // ВИГРЫШ ПЕРВАГО
            if ((a1 > a3 && b2 > b4) && (a2 > a3 && b1 > b4))
                if ((a1 > a4 && b2 > b3) && (a2 > a4 && b1 > b3))
                {
                    if (!svinka)
                        Console.WriteLine("Team 1");
                    else
                        Console.WriteLine("Draw");

                    return;
                }

            Console.WriteLine("Draw");

            return;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ContestA
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] pass1 = Console.ReadLine().Split(' ');
            string[] pass2 = Console.ReadLine().Split(' ');
            string[] pass3 = Console.ReadLine().Split(' ');
            string[] pass4 = Console.ReadLine().Split(' ');

            int a1 = Convert.ToInt32(pass1[0]);
            int b1 = Convert.ToInt32(pass1[1]);
            int a2 = Convert.ToInt32(pass2[0]);
            int b2 = Convert.ToInt32(pass2[1]);
            int a3 = Convert.ToInt32(pass3[0]);
            int b3 = Convert.ToInt32(pass3[1]);
            int a4 = Convert.ToInt32(pass4[0]);
            int b4 = Convert.ToInt32(pass4[1]);

            // АСАБЫЙ СЛУЧАЙ - ОДИНАКОВО ИГРОКИ
            bool svinka = false;
            if (a1 == a3 || a2 == a4 || b1 == b3 || b2 == b4)
                svinka = true;

            // ВИГРЫШ ВТОРОГА
            int can = 0;
            int testA1 = a1, testB1 = b2;

            if ((a3 > testA1 && b4 > testB1) || (a4 > testA1 && b3 > testB1))
            {
                can++;
                // Console.WriteLine("Team 2");
                // return;
            }

            testA1 = a2; testB1 = b1;

            if ((a3 > testA1 && b4 > testB1) || (a4 > testA1 && b3 > testB1))
            {
                can++;
                // Console.WriteLine("Team 2");
                // return;
            }

            // ВИГРЫШ ПЕРВАГО
            int can2 = 0;

            if ((a1 > a3 && b2 > b4) || (a2 > a3 && b1 > b4))
                can2++;

            if ((a1 > a4 && b2 > b3) || (a2 > a4 && b1 > b3))
                can2++;

            if (can == 2)
                Console.WriteLine("Team 2");
            else if (can2 == 2)
            {
                if(!svinka)
                    Console.WriteLine("Team 1");
                else
                    Console.WriteLine("Draw");
            }
            else
                Console.WriteLine("Draw");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ContestA
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] pass1 = Console.ReadLine().Split(' ');
            string[] pass2 = Console.ReadLine().Split(' ');
            string[] pass3 = Console.ReadLine().Split(' ');
            string[] pass4 = Console.ReadLine().Split(' ');

            int a1 = Convert.ToInt32(pass1[0]);
            int b1 = Convert.ToInt32(pass1[1]);
            int a2 = Convert.ToInt32(pass2[0]);
            int b2 = Convert.ToInt32(pass2[1]);
            int a3 = Convert.ToInt32(pass3[0]);
            int b3 = Convert.ToInt32(pass3[1]);
            int a4 = Convert.ToInt32(pass4[0]);
            int b4 = Convert.ToInt32(pass4[1]);

            // АСАБЫЙ СЛУЧАЙ - ОДИНАКОВО ИГРОКИ
            bool svinka = false;
            if (a1 == a3 || a2 == a4 || b1 == b3 || b2 == b4)
                svinka = true;

            // ВИГРЫШ ВТОРОГА
            if ((a3 > a1 && b4 > b2) || (a4 > a1 && b3 > b2))
                if ((a3 > a2 && b4 > b1) || (a4 > a2 && b3 > b1))
                {
                    Console.WriteLine("Team 2");

                    return;
                }

            // ВИГРЫШ ПЕРВАГО
            if ((a1 > a3 && b2 > b4) || (a2 > a3 && b1 > b4))
                if ((a1 > a4 && b2 > b3) || (a2 > a4 && b1 > b3))
                {
                    if (!svinka)
                        Console.WriteLine("Team 1");
                    else
                        Console.WriteLine("Draw");

                    return;
                }

            Console.WriteLine("Draw");

            return;
        }
    }
}

// Submitted by Silithus @ Macau
using System;
using System.IO;
using System.Collections.Generic;
using CCF_XOI;

namespace RCC2014
{
	class QR_C
	{
		private int beat(int a_atk, int a_def, int b_atk, int b_def)
		{
			if (a_atk > b_atk && a_def > b_def) return 1;
			if (b_atk > a_atk && b_def > a_def) return -1;
			return 0;
		}

		public void Solve(XOI xoi)
		{
			int i, j, res, ans;
			int[,] team;
			string[] ans_words = { "Team 2", "Draw", "Team 1" };

			team = new int[4, 2];
			for (i = 0; i < 4; i++)
				for (j = 0; j < 2; j++)
					team[i, j] = xoi.ReadInt();

			for (i = 0, ans = -1999; i <= 1; i++)
			{
				for (j = 2, res = 1999; j <= 3; j++)
					res = Math.Min(res, beat(team[i, 1], team[1 - i, 0], team[j, 1], team[5 - j, 0]));
				ans = Math.Max(ans, res);
			}

			xoi.o.WriteLine(ans_words[ans + 1]);
		}
	}

	class RCC2014_QR
	{
		static void Main(string[] args)
		{
			XOI xoi = new XOI();
			(new QR_C()).Solve(xoi);
		}
	}
}

namespace CCF_XOI
{
	class XOI
	{
		protected StreamReader sr;
		public StreamWriter o;
		protected Queue<string> buf = new Queue<string>();
		public bool EOF = false;

		public XOI()
		{
			this.sr = new StreamReader(Console.OpenStandardInput());
			this.o = new StreamWriter(Console.OpenStandardOutput());
			this.o.AutoFlush = true;
		}

		public XOI(string in_path, string out_path)
		{
			this.sr = new StreamReader(in_path);
			this.o = new StreamWriter(out_path);
			this.o.AutoFlush = true;
		}

		public int ReadInt()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int32.Parse(s);
		}

		public long ReadLong()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Int64.Parse(s);
		}

		public double ReadDouble()
		{
			string s = this.GetNext();
			if (s == null) return -1;
			else return Double.Parse(s);
		}

		public string ReadString()
		{
			string s = this.GetNext();
			return (s == null ? null : s);
		}

		public string ReadLine()
		{	// I will ignore current buffer and read a new line
			string s = "";
			while (s == "" && !this.EOF)
			{
				s = sr.ReadLine();
				this.EOF = (s == null);
			}
			return (this.EOF ? null : s);
		}

		protected string GetNext()
		{
			if (buf.Count == 0)
			{
				while (buf.Count == 0 && !this.EOF)
				{
					string s = sr.ReadLine();
					if (s == null)
						this.EOF = true;
					else
						foreach (string ss in s.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
							buf.Enqueue(ss);
				}
			}

			return (this.EOF ? null : buf.Dequeue());
		}
	}
}

using System;
using System.IO;
using System.Text;

namespace Kicker
{
    internal class Program
    {
        private static readonly StreamReader reader =
            new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);

        private static readonly StreamWriter writer =
            new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            var tt = new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                string[] ss = reader.ReadLine().Split(' ');
                int a = int.Parse(ss[0]);
                int d = int.Parse(ss[1]);
                tt[i, 0] = a;
                tt[i, 1] = d;
            }

            bool fwin = false;
            int swin = 0;

            for (int i = 0; i < 2; i++)
            {
                int a1 = tt[i, 0];
                int b1 = tt[1 - i, 1];
                int s1 = 0, s2 = 0;
                for (int j = 2; j < 4; j++)
                {
                    int a2 = tt[j, 0];
                    int b2 = tt[5 - j, 1];

                    if (a2 > b1 && b2 > a1)
                        s2++;
                    if (a2 < b1 && b2 < a1)
                        s1++;
                }
                if (s1 == 2)
                    fwin = true;
                if (s2 > 1)
                    swin++;
            }

            if (fwin)
                writer.WriteLine("Team 1");
            else if (swin == 2)
                writer.WriteLine("Team 2");
            else
            {
                writer.WriteLine("Draw");
            }
            writer.Flush();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;

int max1=a[0,0]+a[1,1];
if (max1>=a[0,1]+a[1,0])
{powAttack1=a[1,1];
    powProtect1=a[0,0];
}
else
{powAttack1=a[0,1];
    powProtect1=a[1,0];

}
            max1=a[2,0]+a[3,1];
            int powAttack21=0;
            int powProtect21 = 0;
if (max1>a[2,1]+a[3,0])
{powAttack2=a[3,1];
    powProtect2=a[2,0];
}
else
    if (max1 < a[2, 1] + a[3, 0])
    {
        powAttack2 = a[2, 1];
        powProtect2 = a[3, 0];

    }
    else
    {
        powAttack2 = a[3, 1];
        powProtect2 = a[2, 0];
        powAttack21 = a[2, 1];
        powProtect21 = a[3, 0];
    }

if((powProtect1 > powProtect2) && (powAttack1 > powAttack2)){
Console.WriteLine(win1);
}else if(((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21))){
Console.WriteLine(win2);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;
int powProtect11 = 0;
int powAttack11 = 0;
int powProtect21 = 0;
int powAttack21 = 0;
powAttack1 = a[1, 1];
powProtect1 = a[0, 0];
powAttack11 = a[0, 1];
powProtect11 = a[1, 0];

      powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];
if ((((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21)))&&(((powProtect11 < powProtect2) && (powAttack11 < powAttack2))||((powProtect11 < powProtect21) && (powAttack11 < powAttack21)))){

Console.WriteLine(win2);
}
else if (((powProtect11 > powProtect2) && (powAttack11 > powAttack2) && (powProtect11 > powProtect21) && (powAttack11 > powAttack21)) || ((powProtect1 > powProtect2) && (powAttack1 > powAttack2) && (powProtect1 > powProtect21) && (powAttack1 > powAttack21)))
{  Console.WriteLine(win1);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;
int powProtect11 = 0;
int powAttack11 = 0;
int powProtect21 = 0;
int powAttack21 = 0;
powAttack1 = a[1, 1];
powProtect1 = a[0, 0];
powAttack11 = a[0, 1];
powProtect11 = a[1, 0];

      powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];

if (((powProtect11 > powProtect2) && (powAttack11 > powAttack2) && (powProtect11 > powProtect21) && (powAttack11 > powAttack21))||((powProtect1 > powProtect2) && (powAttack1 > powAttack2) && (powProtect1 > powProtect21) && (powAttack1 > powAttack21)))
{
Console.WriteLine(win1);
}else if ((((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21)))&&(((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21)))){
Console.WriteLine(win2);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;
int powProtect11 = 0;
int powAttack11 = 0;
int powProtect21 = 0;
int powAttack21 = 0;
powAttack1 = a[1, 1];
powProtect1 = a[0, 0];
powAttack11 = a[0, 1];
powProtect11 = a[1, 0];

      powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];
    if ((((powProtect1 < powAttack2) && (powAttack1 < powProtect2)) || ((powProtect1 < powAttack21) && (powAttack1 < powProtect21))) && (((powProtect11 < powAttack2) && (powAttack11 < powProtect2)) || ((powProtect11 < powAttack21) && (powAttack11 < powProtect21))))
    {

Console.WriteLine(win2);
}
    else if (((powProtect11 > powAttack2) && (powAttack11 > powProtect2) && (powProtect11 > powProtect21) && (powAttack11 > powProtect21)) || ((powProtect1 > powAttack2) && (powAttack1 > powProtect2) && (powProtect1 > powAttack21) && (powAttack1 > powProtect21)))
{  Console.WriteLine(win1);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;

int max1=a[0,0]+a[1,1];
if (max1>=a[0,1]+a[1,0])
{powAttack1=a[1,1];
    powProtect1=a[0,0];
}
else
{powAttack1=a[0,1];
    powProtect1=a[1,0];

}
            max1=a[2,0]+a[3,1];
            int powAttack21=0;
            int powProtect21 = 0;
if (max1>a[2,1]+a[3,0])
{powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];
}
else
    if (max1 < a[2, 1] + a[3, 0])
    {
        powAttack2 = a[2, 1];
        powProtect2 = a[3, 0];
        powAttack21 = a[3, 1];
        powProtect21 = a[2, 0];

    }
    else
    {
        powAttack2 = a[3, 1];
        powProtect2 = a[2, 0];
        powAttack21 = a[2, 1];
        powProtect21 = a[3, 0];
    }

if ((powProtect1 > powProtect2) && (powAttack1 > powAttack2) && (powProtect1 > powProtect21) && (powAttack1 > powAttack21))
{
Console.WriteLine(win1);
}else if(((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21))){
Console.WriteLine(win2);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;
int powProtect11 = 0;
int powAttack11 = 0;
int powProtect21 = 0;
int powAttack21 = 0;
powAttack1 = a[1, 1];
powProtect1 = a[0, 0];
powAttack11 = a[0, 1];
powProtect11 = a[1, 0];

      powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];

if (((powProtect11 > powProtect2) && (powAttack11 > powAttack2) && (powProtect11 > powProtect21) && (powAttack11 > powAttack21))||((powProtect1 > powProtect2) && (powAttack1 > powAttack2) && (powProtect1 > powProtect21) && (powAttack1 > powAttack21)))
{
Console.WriteLine(win1);
}else if ((((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21)))&&(((powProtect11 < powProtect2) && (powAttack11 < powAttack2))||((powProtect11 < powProtect21) && (powAttack11 < powAttack21)))){
Console.WriteLine(win2);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;

int max1=a[0,0]+a[1,1];
if (max1>=a[0,1]+a[1,0])
{powAttack1=a[1,1];
    powProtect1=a[0,0];
}
else
{powAttack1=a[0,1];
    powProtect1=a[1,0];

}
            max1=a[2,0]+a[3,1];
if (max1>=a[2,1]+a[3,0])
{powAttack2=a[3,1];
    powProtect1=a[2,0];
}
else
{powAttack2=a[2,1];
    powProtect2=a[3,0];

}

if((powProtect1 > powProtect2) && (powAttack1 > powAttack2)){
Console.WriteLine(win1);
}else if((powProtect1 < powProtect2) && (powAttack1 < powAttack2)){
Console.WriteLine(win2);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            var s=" ";
            string[] all;
            int[,] a=new int[4,2];
            for (int i = 0; i < 4; i++)
            {
                s=Console.ReadLine();
                all = s.Split(' ');
                a[i, 0] = Convert.ToInt32(all[0]);
                a[i, 1] = Convert.ToInt32(all[1]);
            }
            String win1 = "Team 1";
String win2 = "Team 2";
String draw = "Draw";

int powProtect1 = 0;
int powAttack1 = 0;
int powProtect2 = 0;
int powAttack2 = 0;

int max1=a[0,0]+a[1,1];
if (max1>=a[0,1]+a[1,0])
{powAttack1=a[1,1];
    powProtect1=a[0,0];
}
else
{powAttack1=a[0,1];
    powProtect1=a[1,0];

}
            max1=a[2,0]+a[3,1];
            int powAttack21=0;
            int powProtect21 = 0;
if (max1>a[2,1]+a[3,0])
{powAttack2=a[3,1];
    powProtect2=a[2,0];
    powAttack21 = a[2, 1];
    powProtect21 = a[3, 0];
}
else
    if (max1 < a[2, 1] + a[3, 0])
    {
        powAttack2 = a[2, 1];
        powProtect2 = a[3, 0];
        powAttack21 = a[3, 1];
        powProtect21 = a[2, 0];

    }
    else
    {
        powAttack2 = a[3, 1];
        powProtect2 = a[2, 0];
        powAttack21 = a[2, 1];
        powProtect21 = a[3, 0];
    }

if((powProtect1 > powProtect2) && (powAttack1 > powAttack2)){
Console.WriteLine(win1);
}else if(((powProtect1 < powProtect2) && (powAttack1 < powAttack2))||((powProtect1 < powProtect21) && (powAttack1 < powAttack21))){
Console.WriteLine(win2);
}else{
Console.WriteLine(draw);
}

        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Threading;
using System.Linq;

class TEST{
	static void Main(){
		Player[] P=new Player[4];
		for(int i=0;i<4;i++){
			var s=Console.ReadLine().Split(' ');
			P[i]=new Player(int.Parse(s[0]),int.Parse(s[1]));
		}

		int[][] Score=new int[2][];
		for(int i=0;i<2;i++)Score[i]=new int[2];

		int off1=0;
		int off2=0;
		int def1=0;
		int def2=0;

		for(int i=0;i<2;i++){
			if(i==0){off1=P[0].Off;def1=P[1].Def;}
			if(i==1){off1=P[1].Off;def1=P[0].Def;}

			for(int j=0;j<2;j++){
				if(j==0){off2=P[2].Off;def2=P[3].Def;}
				if(j==1){off2=P[3].Off;def2=P[2].Def;}

				if(off1>off2 && def1>def2){Score[i][j]=1;continue;}
				if(off1<off2 && def1<def2){Score[i][j]=2;continue;}
				Score[i][j]=3;
			}
		}
		bool chk1=false;
		for(int i=0;i<2;i++){
			if(Score[i][0]==1 &&Score[i][1]==1)chk1=true;
		}

		bool chk2=true;
		for(int i=0;i<2;i++){
			if(Score[i][0]!=2 &&Score[i][1]!=2)chk2=false;
		}

		Console.WriteLine(chk1?"Team 1":(chk2?"Team 2":"Draw"));

	}
}

struct Player{
	public int Off;
	public int Def;
	public Player(int o,int d){
		Off=o;Def=d;
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Threading;
using System.Linq;

class TEST{
	static void Main(){
		Player[] P=new Player[4];
		for(int i=0;i<4;i++){
			var s=Console.ReadLine().Split(' ');
			P[i]=new Player(int.Parse(s[1]),int.Parse(s[0]));
		}

		int[][] Score=new int[2][];
		for(int i=0;i<2;i++)Score[i]=new int[2];

		int off1=0;
		int off2=0;
		int def1=0;
		int def2=0;

		for(int i=0;i<2;i++){
			if(i==0){off1=P[0].Off;def1=P[1].Def;}
			if(i==1){off1=P[1].Off;def1=P[0].Def;}

			for(int j=0;j<2;j++){
				if(j==0){off2=P[2].Off;def2=P[3].Def;}
				if(j==1){off2=P[3].Off;def2=P[2].Def;}

				if(off1>off2 && def1>def2){Score[i][j]=1;continue;}
				if(off1<off2 && def1<def2){Score[i][j]=2;continue;}
				Score[i][j]=3;
			}
		}
		bool chk1=false;
		for(int i=0;i<2;i++){
			if(Score[i][0]==1 &&Score[i][1]==1)chk1=true;
		}

		bool chk2=true;
		for(int i=0;i<2;i++){
			if(Score[i][0]!=2 &&Score[i][1]!=2)chk2=false;
		}

		Console.WriteLine(chk1?"Team 1":(chk2?"Team 2":"Draw"));

	}
}

struct Player{
	public int Off;
	public int Def;
	public Player(int o,int d){
		Off=o;Def=d;
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;

namespace Algorithm
{
    class Solver
    {
        Player[] a = new Player[4];

        public void Run()
        {
            for (int i = 0; i < 4; i++)
            {
                string[] tokens = cin.ReadLine().Split();
                int x = int.Parse(tokens[0]);
                int y = int.Parse(tokens[1]);
                a[i] = new Player(x, y);
            }

            if (can_win(a[0].Defence, a[1].Attak, a[2].Defence, a[3].Attak) &&
                can_win(a[0].Defence, a[1].Attak, a[3].Defence, a[2].Attak))
            {
                cout.WriteLine("Team 1");
                return;
            }
            if (can_win(a[1].Defence, a[0].Attak, a[2].Defence, a[3].Attak) &&
                can_win(a[1].Defence, a[0].Attak, a[3].Defence, a[2].Attak))
            {
                cout.WriteLine("Team 1");
                return;
            }

            int cnt = 0;
            if (can_win(a[2].Defence, a[3].Attak, a[0].Defence, a[1].Attak) ||
               can_win(a[3].Defence, a[2].Attak, a[1].Defence, a[0].Attak)) cnt++;
            if (can_win(a[2].Defence, a[3].Attak, a[0].Defence, a[1].Attak) ||
                can_win(a[3].Defence, a[2].Attak, a[1].Defence, a[0].Attak)) cnt++;
            if (cnt == 2)
                cout.WriteLine("Team 2");
            else
                cout.WriteLine("Draw");
        }

        bool can_win(int a, int b, int c, int d)
        {
            if (a > d && b > c) return true;
            return false;
        }

        void Swap(ref int a, ref int b)
        {
            int tmp = a;
            a = b;
            b = tmp;
        }

        public StreamReader cin = null;
        public StreamWriter cout = null;
    }

    class Player
    {
        public Player() { }
        public Player(int _a, int _d)
        {
            this.Attak = _a;
            this.Defence = _d;
        }
        public int Attak;
        public int Defence;
    }

    class Program
    {
        public static void Main(string[] args)
        {
            Solver task = new Solver();
#if DEBUG
            task.cin = new StreamReader("input.txt");
            task.cout = new StreamWriter("output.txt");
#else
            task.cin = new StreamReader(Console.OpenStandardInput());
            task.cout = new StreamWriter(Console.OpenStandardOutput());
#endif
            task.cout.AutoFlush = true;
            task.Run();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;

namespace Algorithm
{
    class Solver
    {
        Player[] a = new Player[4];

        public void Run()
        {
            for (int i = 0; i < 4; i++)
            {
                string[] tokens = cin.ReadLine().Split();
                int x = int.Parse(tokens[0]);
                int y = int.Parse(tokens[1]);
                a[i] = new Player(x, y);
            }

            if (can_win(a[0].Defence, a[1].Attak, a[2].Defence, a[3].Attak) &&
                can_win(a[0].Defence, a[1].Attak, a[3].Defence, a[2].Attak))
            {
                cout.WriteLine("Team 1");
                return;
            }
            if (can_win(a[1].Defence, a[0].Attak, a[2].Defence, a[3].Attak) &&
                can_win(a[1].Defence, a[0].Attak, a[3].Defence, a[2].Attak))
            {
                cout.WriteLine("Team 1");
                return;
            }

            int cnt = 0;
            if (can_win(a[2].Defence, a[3].Attak, a[0].Defence, a[1].Attak) ||
               can_win(a[3].Defence, a[2].Attak, a[1].Defence, a[0].Attak)) cnt++;
            if (can_win(a[2].Defence, a[3].Attak, a[0].Defence, a[1].Attak) &&
                can_win(a[3].Defence, a[2].Attak, a[1].Defence, a[0].Attak)) cnt++;
            if (cnt == 2)
                cout.WriteLine("Team 2");
            else
                cout.WriteLine("Draw");
        }

        bool can_win(int a, int b, int c, int d)
        {
            if (a > d && b > c) return true;
            return false;
        }

        void Swap(ref int a, ref int b)
        {
            int tmp = a;
            a = b;
            b = tmp;
        }

        public StreamReader cin = null;
        public StreamWriter cout = null;
    }

    class Player
    {
        public Player() { }
        public Player(int _a, int _d)
        {
            this.Attak = _a;
            this.Defence = _d;
        }
        public int Attak;
        public int Defence;
    }

    class Program
    {
        public static void Main(string[] args)
        {
            Solver task = new Solver();
#if DEBUG
            task.cin = new StreamReader("input.txt");
            task.cout = new StreamWriter("output.txt");
#else
            task.cin = new StreamReader(Console.OpenStandardInput());
            task.cout = new StreamWriter(Console.OpenStandardOutput());
#endif
            task.cout.AutoFlush = true;
            task.Run();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ContestA
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] pass1 = Console.ReadLine().Split(' ');
            string[] pass2 = Console.ReadLine().Split(' ');
            string[] pass3 = Console.ReadLine().Split(' ');
            string[] pass4 = Console.ReadLine().Split(' ');

            int a1 = Convert.ToInt32(pass1[0]);
            int b1 = Convert.ToInt32(pass1[1]);
            int a2 = Convert.ToInt32(pass2[0]);
            int b2 = Convert.ToInt32(pass2[1]);
            int a3 = Convert.ToInt32(pass3[0]);
            int b3 = Convert.ToInt32(pass3[1]);
            int a4 = Convert.ToInt32(pass4[0]);
            int b4 = Convert.ToInt32(pass4[1]);

            // АСАБЫЙ СЛУЧАЙ - ОДИНАКОВО ИГРОКИ
            bool svinka = false;
            if (a1 == a3 || a2 == a4 || b1 == b3 || b2 == b4)
                svinka = true;

            // ВИГРЫШ ВТОРОГА
            if ((a3 > a1 && b4 > b2) || (a4 > a1 && b3 > b2))
                if ((a3 > a2 && b4 > b1) || (a4 > a2 && b3 > b1))
                {
                    Console.WriteLine("Team 2");

                    return;
                }

            // ВИГРЫШ ПЕРВАГО
            if ((a1 > a3 && b2 > b4) || (a2 > a3 && b1 > b4))
                if ((a1 > a4 && b2 > b3) || (a2 > a4 && b1 > b3))
                {
                    //if (!svinka)
                        Console.WriteLine("Team 1");
                    //else
                    //    Console.WriteLine("Draw");

                    return;
                }

            Console.WriteLine("Draw");

            return;
        }
    }
}