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

namespace Contest
{
    class Program
    {
        private Scanner sc;

        public void Solve()
        {
            sc = new Scanner();
            int A = sc.NextInt();
            int B = sc.NextInt();
            if (A == B)
            {
                Console.WriteLine("Draw");
                return;
            }

            if (A == 1)
            {
                Console.WriteLine("Alice");
                return;
            }

            if (B == 1)
            {
                Console.WriteLine("Bob");
                return;
            }
            Console.WriteLine(A > B ? "Alice" : "Bob");
        }

        static void Main() => new Program().Solve();
    }
}


class Algorithm
{
    #region NextPermutation
    public static bool NextPermutation<T>(T[] array, int start, int length)
    {
        return NextPermutation(array, start, length, Comparer<T>.Default);
    }

    public static bool NextPermutation<T>(T[] array, int start, int length, IComparer<T> comparer)
    {
        return NextPermutation(array, start, length, comparer.Compare);
    }

    public static bool NextPermutation<T>(T[] array, int start, int length, Comparison<T> compare)
    {
        int end = start + length - 1;

        if (end <= start) return false;

        int last = end;
        while (true)
        {
            int pos = last--;
            if (compare(array[last], array[pos]) < 0)
            {
                int i;
                for (i = end + 1; compare(array[last], array[--i]) >= 0;) ;
                T tmp = array[last];
                array[last] = array[i];
                array[i] = tmp;
                Array.Reverse(array, pos, end - pos + 1);
                return true;
            }

            if (last == start)
            {
                Array.Reverse(array, start, end - start);
                return false;
            }
        }

        throw new Exception("NextPermutation: Fatal error");
    }

    public static bool NextPermutation<T>(T[] array, IComparer<T> comparer)
    {
        return NextPermutation(array, 0, array.Length, comparer);
    }

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

    public static bool NextPermutation<T>(T[] array)
    {
        return NextPermutation(array, 0, array.Length);
    }

    #endregion
    #region BitCount
    int BitCount(int n)
    {
        n = (n & 0x55555555) + (n >> 1 & 0x55555555);
        n = (n & 0x33333333) + (n >> 2 & 0x33333333);
        n = (n & 0x0f0f0f0f) + (n >> 4 & 0x0f0f0f0f);
        n = (n & 0x00ff00ff) + (n >> 8 & 0x00ff00ff);
        return (n & 0x0000ffff) + (n >> 16 & 0x0000ffff);
    }
    #endregion
    #region LowerBound
    public static int LowerBound<T>(T[] array, T target, Comparison<T> comparison)
    {
        int ok = array.Length;
        int ng = -1;
        while (ok - ng > 1)
        {
            int med = (ok + ng) / 2;
            if (comparison(array[med], target) < 0) ng = med;
            else ok = med;
        }

        return ok;
    }
    public static int LowerBound<T>(T[] array, T target, IComparer<T> comparer) =>
        LowerBound(array, target, comparer.Compare);
    public static int LowerBound<T>(T[] array, T target) => LowerBound(array, target, Comparer<T>.Default);
    #endregion
    #region UpperBound
    public static int UpperBound<T>(T[] array, T target, Comparison<T> comparison)
    {
        int ok = array.Length;
        int ng = -1;
        while (ok - ng > 1)
        {
            int med = (ok + ng) / 2;
            if (comparison(array[med], target) <= 0) ng = med;
            else ok = med;
        }

        return ok;
    }

    public static int UpperBound<T>(T[] array, T target, IComparer<T> comparer) =>
        UpperBound(array, target, comparer.Compare);

    public static int UpperBound<T>(T[] array, T target) => UpperBound(array, target, Comparer<T>.Default);
    #endregion
    #region GCD
    static public long GCD(long a, long b)
    {
        while (a % b != 0)
        {
            long t = a % b;
            a = b;
            b = t;
        }

        return b;
    }
    #endregion
    #region LCM
    static public long LCM(long a, long b)
    {
        return a * b / GCD(a, b);
    }

    #endregion
}

class Scanner
{
    public Scanner()
    {
        _stream = new StreamReader(Console.OpenStandardInput());
        _pos = 0;
        _line = new string[0];
        _separator = ' ';
    }
    private readonly char _separator;
    private readonly StreamReader _stream;
    private int _pos;
    private string[] _line;
    #region get a element
    public string Next()
    {
        if (_pos >= _line.Length)
        {
            _line = _stream.ReadLine().Split(_separator);
            _pos = 0;
        }
        return _line[_pos++];
    }
    public int NextInt()
    {
        return int.Parse(Next());
    }
    public long NextLong()
    {
        return long.Parse(Next());
    }
    public double NextDouble()
    {
        return double.Parse(Next());
    }
    #endregion
    #region convert array
    private int[] ToIntArray(string[] array)
    {
        var result = new int[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = int.Parse(array[i]);
        }

        return result;
    }
    private long[] ToLongArray(string[] array)
    {
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = long.Parse(array[i]);
        }

        return result;
    }
    private double[] ToDoubleArray(string[] array)
    {
        var result = new double[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = double.Parse(array[i]);
        }

        return result;
    }
    #endregion
    #region get array
    public string[] Array()
    {
        if (_pos >= _line.Length)
            _line = _stream.ReadLine().Split(_separator);
        _pos = _line.Length;
        return _line;
    }
    public int[] IntArray()
    {
        return ToIntArray(Array());
    }
    public long[] LongArray()
    {
        return ToLongArray(Array());
    }
    public double[] DoubleArray()
    {
        return ToDoubleArray(Array());
    }
    #endregion
}

Measured memory_bytes: 11092