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

namespace NumberWars
{
    class Startup
    {
        private static Queue<KeyValuePair<int, char>> playerOneDeck;
        private static Queue<KeyValuePair<int, char>> playerTwoDeck;

        private static List<KeyValuePair<int, char>> board;

        private static bool hasWinner;

        static void Main()
        {
            board = new List<KeyValuePair<int, char>>();

            InitDeck(ref playerOneDeck);
            InitDeck(ref playerTwoDeck);

            var turns = 0;

            while (turns <= 1000000 || hasWinner == false)
            {
                if (playerOneDeck.Count == 0 ||
                    playerTwoDeck.Count == 0)
                {
                    hasWinner = true;
                    break;
                }
                else
                {
                    Turn();
                    turns++;
                }
            }

            var result = string.Empty;
            if (playerOneDeck.Count == playerTwoDeck.Count)
            {
                result = "Draw";
            }
            else
            {
                result = $"{(playerOneDeck.Count > playerTwoDeck.Count ? "First" : "Second")} player wins";
            }

            Console.WriteLine($"{result} after {turns} turns");
        }

        private static void Turn()
        {
            board.Clear();

            var playerOneCard = GetCard(playerOneDeck);
            var playerTwoCard = GetCard(playerTwoDeck);

            CompareScore(playerOneCard.Key, playerTwoCard.Key);
        }

        private static void CompareScore(int playerOneScore, int playerTwoScore)
        {
            // player one takes
            if (playerOneScore > playerTwoScore)
            {
                TransferBoardCards(playerOneDeck);
            }
            // player two takes
            else if (playerOneScore < playerTwoScore)
            {
                TransferBoardCards(playerTwoDeck);
            }
            else
            {
                // both have same score
                if(playerOneDeck.Count >= 3 && playerTwoDeck.Count >= 3)
                {
                    War();
                }
                else
                {
                    hasWinner = true;
                }
            }
        }

        private static void War()
        {
            var playerOneSum = 0;
            var playerTwoSum = 0;

            for (int iter = 0; iter < 3; iter++)
            {
                playerOneSum += (GetCard(playerOneDeck).Value - 'a' + 1);
                playerTwoSum += (GetCard(playerTwoDeck).Value - 'a' + 1);
            }

            CompareScore(playerOneSum, playerTwoSum);
        }

        private static void TransferBoardCards(Queue<KeyValuePair<int, char>> deck)
        {
            var ordered = board
                .OrderByDescending(x => x.Key)
                .ThenByDescending(x => x.Value);

            foreach (var item in ordered)
            {
                deck.Enqueue(item);
            }
        }

        private static KeyValuePair<int, char> GetCard(Queue<KeyValuePair<int, char>> deck)
        {
            var card = deck.Dequeue();
            board.Add(card);

            return card;
        }

        private static void InitDeck(ref Queue<KeyValuePair<int, char>> deck)
        {
            deck = new Queue<KeyValuePair<int, char>>();

            var data = Console.ReadLine().Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);

            var reg = new Regex(@"(?<number>\d+)(?<card>\w+)");

            foreach (var item in data)
            {
                var match = reg.Match(item);

                var number = int.Parse(match.Groups["number"].Value);
                var card = match.Groups["card"].Value[0];

                var kvp = new KeyValuePair<int, char>(number, card);

                deck.Enqueue(kvp);
            }
        }
    }
}