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.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 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.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);
}

}
}
}

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();
        }
    }
}

// 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 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;
        }
    }
}