jiahuimbzuai/CoQuIR huggingface dataset:
//  [swift]
let S = Array(readLine()!.characters)
print(String(S[0 ..< 4]) + " " + String(S[4 ..< S.count]))
//  [swift]
let S = Array(readLine()!.characters)
String(S[0 ..< 4]) + " " + String(S[4 ..< S.count])
//  [swift]
extension String {
    var asciiValue: UInt32 {
        guard let first = characters.first where characters.count == 1 else  { return 0 }
        return first.unicodeScalarsValue!
    }
    func asciiValueAt(pos pos: UInt32) -> UInt32 {
        guard characters.count > 0 && Int(pos) < characters.count else  { return 0 }
        return Array(characters)[Int(pos)].unicodeScalarsValue!
    }
}
extension Character {
    var unicodeScalarsValue: UInt32? {
        return String(self).unicodeScalars.first?.value
    }
}

var ss = Array(readLine()!.characters)
var K = Int(readLine()!)!

for i in 0 ..< ss.count {
    let number = Int(ss[i].unicodeScalarsValue!)
    let to = 123 - number
    if to <= K {
        K -= to
        ss[i] = Character("a")
    }
}

if K == 0 {
    print(String(ss))
} else {
    K %= 26
    let last = ss.count - 1
    let unicodeScalar = UnicodeScalar((Int(ss[last].unicodeScalarsValue!) + K - 97) % 26 + 97)
    ss[last] = Character(unicodeScalar)
    print(String(ss))
}
//  [swift]
var s: String = readLine()!
let index = 4
print("\(s.characters.prefix(index)) \(s.characters.suffix(s.characters.count - index))")
//  [typescript]
function main(input) {
  const result = input.substring(0,4) + " " + input.substring(4)
  console.log(result.trim());
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function main(input) {
  console.log(input.substring(0,4) + " " + input.substring(4));
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function main(input) {
  let result = "";
  for(let i = 0; i < input.length; i++) {
    if (i === 4) {
      result = result + " ";
    }
  	result = result + input[i];
  }
  console.log(result + "\n");
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function main(input) {
  let result = "";
  for(let i = 0; i < input.length; i++) {
    if (i === 4) {
      result = result + " ";
    }
  	result = result + input[i];
  }
  console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
n, m =map(int, input().split())
print((n-1) * (m-1))
//  [python]
l = list(map(int, input().split()))
print((l[0]-1)*(l[1]-1))
//  [python]
a,b=map(int,input().split())
print((a-1)*(b-1))
//  [python]
x,y = int(input().split())
print((x-1)*(y-1))
//  [python]
n = int(input())
m = int(input())
print((n - 1) * (m - 1))
//  [python]
n, m = [map(int, input().split()) for i in range(2)]
print((n-1)*(m-1))
//  [java]
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        String[] i = line.split(" ");
        int n = Integer.parseInt(i[0]);
        int m = Integer.parseInt(i[1]);
        int r = (n - 1) * (m - 1);
        System.out.println(r);
    }
}
//  [java]
import java.util.*;
import java.io.*;

class Main{
    public static void main(String[] args){
        FastScanner fsc=new FastScanner();
        System.out.println((fsc.nextInt()-1)*(fsc.nextInt()-1));
        fsc.close();
        
    }
    static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;
        private boolean hasNextByte(){
            if(ptr<buflen) return true;
            else{
                ptr = 0;
                try{
                    buflen = in.read(buffer);
                }
                catch(IOException e){
                    e.printStackTrace();
                }
                if(buflen<=0) return false;
            }
        return true;
        }
        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
        public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while(isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public long nextLong() {
            if (!hasNext()) throw new NoSuchElementException();
            long n = 0;
            boolean minus = false;
            int b = readByte();
            if (b == '-') {
                minus = true;
                b = readByte();
            }
            if (b < '0' || '9' < b) throw new NumberFormatException();
            while(true){
                if ('0' <= b && b <= '9') {
                    n *= 10;
                    n += b - '0';
                }
                else if(b == -1 || !isPrintableChar(b)) return minus ? -n : n;
                else throw new NumberFormatException();
                b = readByte();
            }
        }
        public int nextInt() {
            long nl = nextLong();
            if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
            return (int) nl;
        }
        public double nextDouble() { return Double.parseDouble(next());}
        public void close(){
            try{in.close();}
            catch(IOException e){e.printStackTrace();}
        }
    }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        PrintWriter out = new PrintWriter(System.out);
        InputStreamScanner in = new InputStreamScanner(System.in);
        new Main().solve(in, out);
        out.flush();
    }

    private void solve(InputStreamScanner in, PrintWriter out) {
        int a = in.nextInt();
        int b = in.nextInt();

        out.println((a - 1) * (b - 1));
    }

    static class InputStreamScanner {

        private InputStream in;

        private byte[] buf = new byte[1024];
        private int len = 0;
        private int off = 0;

        InputStreamScanner(InputStream in)	{
            this.in = in;
        }

        String next() {
            StringBuilder sb = new StringBuilder();
            for (int b = skip(); !isSpace(b);){
                sb.appendCodePoint(b);
                b = read();
            }
            return sb.toString();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        char nextChar() {
            return (char)skip();
        }

        int skip() {
            for (int b; (b = read()) != -1;) {
                if (!isSpace(b)) {
                    return b;
                }
            }
            return -1;
        }

        private boolean isSpace(int c) {
            return c < 33 || c > 126;
        }

        private int read() {
            if (len == -1) {
                throw new InputMismatchException("End of Input");
            }
            if (off >= len){
                off = 0;
                try {
                    len = in.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException(e.getMessage());
                }
                if (len <= 0) {
                    return -1;
                }
            }
            return buf[off++];
        }
    }
}
//  [java]


import java.io.IOException;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) throws IOException {

		Scanner scan = new Scanner(System.in);

		int n = scan.nextInt();
		int m = scan.nextInt();

		int ans;
		int tmp_min = Math.min(n, m);

		int i = tmp_min - 1;

		ans = i * i;

		if (n == m) {

			System.out.println(ans);
		} else {
			System.out.println(ans + (tmp_min - 1));
		}
	}

	//***********************以下共通関数************************************************
	/**
	 * 文字列を反転して返す
	 * @param pStr 文字列
	 * @return 反転した文字列
	 */
	public static String myReverse(String pStr) {
		if (pStr.length() < 1) {
			return "";
		}

		StringBuffer sb = new StringBuffer(pStr);
		return sb.reverse().toString();
	}

	/**
	 * 余りを求める。
	 * @param a
	 * @param b
	 * @return 余り。余りがマイナスの時はプラスで返す。
	 */
	public static long myMod(long a, long b) {
		long ret = 0;

		ret = a % b;

		if (ret < 0) {
			ret += b;
		}

		return ret;
	}

	/**
	 * 乗数を求める ※mod対応
	 * @param kisu 基数
	 * @param josu 乗数
	 * @param primeNumMod_0 法 mod値 使わない場合は「0」
	 * @return
	 */
	public static long myPowWithMod(long kisu, long josu, long primeNumMod_0) {

		long ans = 1;

		//乗数が0の場合→1
		if (josu == 0)
			return 1;

		if (primeNumMod_0 == 0) {
			//modを使わないとき

			while (josu > 0) {

				if (josu % 2 == 0) {
					//累乗が偶数の時

					kisu *= kisu;
					josu = josu / 2;
				} else {
					//累乗が奇数の時
					ans *= kisu;
					josu--;
				}
			}

			return ans;

		} else {
			//modを使うとき

			//初めに桁を落とす
			kisu = myMod(kisu, primeNumMod_0);

			while (josu > 0) {

				if (josu % 2 == 0) {
					//累乗が偶数の時

					kisu *= myMod(kisu, primeNumMod_0);
					josu = josu / 2;

				} else {
					//累乗が奇数の時
					ans *= myMod(kisu, primeNumMod_0);
					josu--;

				}
			}

			return myMod(ans, primeNumMod_0);

		}

	}

}
//  [java]
import java.util.Scanner;
     
    public class Main {
      public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int M = sc.nextInt();
        int X = sc.nextInt();
        int []a = new int[N];
        
        int migi = 0;
        int hidari = 0;
        for(int i=0; i<M; i++) {
        	 a[i] = sc.nextInt();
        	 	if(a[i]<X) {
        	 		hidari++;
        	 	}else {
        	 		migi++;
         	 }
        }
      System.out.println(Math.min(migi,hidari));
      }
    }
//  [java]
import java.util.*;

public class Main{
      public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int num1 = sc.nextInt();
            int num2 = sc.nextInt();
            System.out.println((num1-1) * (num2-2));
          }
}
//  [cpp]
#include<cstdio>

using namespace std;

int n,m;

int main () {
	scanf("%d%d", &n, &m);
	printf("%d\n", (n - 1) * (m - 1));
	return 0;	
}
//  [cpp]
#include <cstdio>
using namespace std;
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);n--,m--;
	printf("%d",n * m);
}
//  [cpp]
#include<stdio.h>
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	printf("%d\n",(n-1)*(m-1));
}
//  [cpp]
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<set>

using namespace std;

int main()
{
	int n, m;
	cin >> n >> m;

	cout >> (n - 1)* (m - 1) << endl;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

#define ll long long

signed main()
{
  int n,m; cin >> n >> m;
  int ans = 0;
  //ans = (n+1)*(m+1) -(n+m)*2;
  ans = nm-n-m+1;
  cout << ans << "\n";
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

#define ll long long

signed main()
{
  int n,m; cin >> n >> m;
  cout << n*m -(n+m)*2 << "\n";
}
//  [c]
#include<stdio.h>
int main(void) {
	int n;
	int m;
	int sum;
	scanf("%d %d",&n,&m);

	sum = (n - 1)*(m - 1);
	printf("%d\n",sum);
	return 0;
}
//  [c]
#include <stdio.h>

int main(void)
{
    int n, m, i, j;

    scanf("%d %d", &n, &m);

    printf("%d\n", (n - 1) * (m - 1));
}
//  [c]
#include <stdio.h>
static int n, m;
int main(void) {
    scanf("%d%d", &n, &m);
    printf("%d\n", --n * --m);
    return 0;
}
//  [c]
n, m = map(int, input().split())
print(~-n * ~-m)
//  [c]
#include<stdio.h>
int main(void){
  int i;
  char s[101];
  int ct=0;
  
  for(i=0;i<101;i++){
    s[i]=0;
  }
  
  for(i=0;i<101;i++){
    scanf("%c",&s[i]);
  }
  
  for(i=0;i<101;i++){
    if(s[i] != '0')ct++;
    else break;
  }
  
  printf("%c%d%c\n",s[0],ct-2,s[ct-1]);
  
  return 0;
}
//  [c]
#include <stdio.h>

int main(void){
 	char data[100];
  	int i;
  	scanf("%s",data);
  	for(i=0; data[i]!='\0'; ++i);
  	printf("%c%d%c",data[0],i-2,data[i-1]);
}
//  [javascript]
function Main(input){
	// input = inp;
	var tmp = input.split(" ");
	var n = tmp[0];
	var m = tmp[1];
	var number = (n - 1) * (m - 1);
	console.log(number);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ").map(Number);
console.log((input[0]-1)*(input[1]-1))
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

const main = (input) => {
    const n = parseInt(input.split(' ')[0])
    const m = parseInt(input.split(' ')[1])
    console.log((n - 1) * (m - 1))
}

main(require('fs').readFileSync('/dev/stdin', 'utf-8'))
//  [javascript]
function main(input) {
  const s = input.split('');
  
  const a = s[0].toString();
  const b = (s.length - 2).toString();
  const c = s[s.length - 1];
  
  const result = a.toString()+b.toString()+c.toString();
  
  console.log(result);
}

main(require('fs').readFileSync('/dev/stdin', 'utf-8'));
//  [javascript]
function main(input) {
  var first = input[0];
  var length = input.length - 2;
  var last = input[input.length - 1];
  console.log(first + length + last);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split("").map(String);
  var a = input[0]
console.log(""+a+""+(input.length-2)+""+input[input.length-1]);
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

// Solution for https://atcoder.jp/contests/abc069/tasks/abc069_a

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

type contest struct {
	in  io.Reader
	out io.Writer
}

func (con *contest) Scan(a ...interface{}) (int, error) {
	return fmt.Fscan(con.in, a...)
}
func (con *contest) Scanln(a ...interface{}) (int, error) {
	return fmt.Fscanln(con.in, a...)
}
func (con *contest) Scanf(f string, a ...interface{}) (int, error) {
	return fmt.Fscanf(con.in, f, a...)
}
func (con *contest) Print(a ...interface{}) (int, error) {
	return fmt.Fprint(con.out, a...)
}
func (con *contest) Println(a ...interface{}) (int, error) {
	return fmt.Fprintln(con.out, a...)
}
func (con *contest) Printf(f string, a ...interface{}) (int, error) {
	return fmt.Fprintf(con.out, f, a...)
}
func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	con := &contest{in: in, out: out}
	con.main()
}

func (con *contest) main() error {
	var n, m int
	con.Scan(&n, &m)
	con.Println((n - 1) * (m - 1))
	return nil
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var n, m int ; fmt.Scan(&n, &m)
  fmt.Println((n-1) * (m-1))
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var n, m int
	fmt.Scan(&n, &m)

	fmt.Println(n*m - (n + m - 1))
}
//  [go]
package main 

import {
  "fmt";
  "strings";
}

func main() {
  var s string;
  fmt.Scan(&s);
  
  sLen := len(s)
  fmt.printf("%s%d%s", s[0:1], sLen, s[sLen-1:sLen])
}
//  [ruby]
n, m = gets.chomp.split(' ').map(&:to_i)
ans = (n-1) * (m-1)
print(ans)
//  [ruby]
n,m=gets.split.map(&:to_i)
p (n-1)*(m-1)
//  [ruby]
a, b=gets.split.map &:to_i
p (a-1)*(b-1)
//  [ruby]
n, m = gets.split.map &:to_i

puts (n - 1) * (m = 1)
//  [ruby]
s = gets.chomp
m = s.length - 2
newStr = s[1, m]
newStr = newStr.length
l = s.length - 1
lastStr = s[l, 1]
p "#{s[0, 1]}#{newStr}#{lastStr}"
//  [ruby]
n, m = gets.chomp.map(&:to_i)
puts (n - 1) * (m - 1)
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: usize = read();
    let m: usize = read();
    println!("{}", (n - 1) * (m - 1));
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
       n: u32,
       m: u32,
    }
    println!("{}", (n-1) * (m-1));
}
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let n = v[0];
	let m = v[1];
	println!("{}", (m-1)*(n-1) );
}
//  [rust]
#![allow(unused_imports)]
// use itertools::Itertools;
use proconio::{input, marker::*};

fn main() {
    input! {
        n: i8,
        m: i8
    };
    println!("{}", (n - 1) * (m - 1));
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {n: usize, m:usize};

    println!("{}", n - 1 * m - 1)
}
//  [swift]
print(readLine()!.characters.split(" ").reduce(1){$0*(Int(String($1))!-1)})
//  [swift]
import Glibc
extension String: CollectionType {}

var nm = readLine()!.split(" ").map { Int($0)! }
print(nm.reduce(1) { $0 * ($1 - 1) })
//  [swift]
extension String: CollectionType {}
let nm = readLine()!.split(" ").flatMap({ Int($0) })
print((nm[0]-1)*(nm[1]-1))
//  [swift]
print(readLine()!.characters.split(" ").reduce(1){--Int(String($1))!*$0})
//  [swift]
print(readLine()!.characters.split(" ").reduce(1){$0*Int(String($1))!-1})
//  [swift]
print(readLine()!.characters.split(" ").reduce(1){$0*Int(String($1))!--})
//  [typescript]
const t={input:require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/),n:(arg:number=0):any=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.n())}return a}else{const a=t.input[0];t.input.shift();return Number(a)}},s:(arg:number=0):string|string[]=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.s())}return a}else{const a=t.input[0];t.input.shift();return String(a)}},c:(arg:number=0):string|string[]=>{if(arg){const a=[];for(let i=0;i<arg;i++){a.push(t.c())}return a}else{let a=t.input[0].split('');const b=a[0];a.shift();if(a.length>0){t.input[0]=a.join('')}else{t.input.shift()}return String(b)}},o:(...arg)=>{console.log(...arg)},abs:(a)=>{return Math.abs(a)},min:(...a)=>{return Math.min(...a)},max:(...a)=>{return Math.max(...a)},floor:(a)=>{return Math.floor(a)},asc:(ar:number[])=>{return ar.sort((a,b)=>{return a-b})},desc:(ar:number[])=>{return ar.sort((a,b)=>{return b-a})},sw:(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length;i+=2){if(eval(a+op+arr[i]))return arr[i+1];}return arr[arr.length-1]}};
const main=()=>{
  t.o((t.n()-1)*(t.n()-1))
}
main()
//  [typescript]
import * as fs from 'fs';

const [n, m]: number[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(Number);

const ans :number = (n - 1) * (m - 1)
console.log(ans);
//  [typescript]
console.log(require('fs').readFileSync('/dev/stdin', 'utf-8').toString().split('\n')[0].split(' ').map(Number).map(x => x - 1).reduce((a, b) => a * b))
//  [typescript]
import * as fs from 'fs';

const [n, m]: bigint[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(BigInt);
const ans :bigint = (n - BigInt(1)) * (m - BigInt(1))
console.log(ans.toString());
//  [python]
a,b = [int(x) for x in input().split()]

if a == b:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
elif a > b:
    print("Alice")
else:
    print("Bob")
//  [python]
a, b = map(int, input().split())

l = ["Alice", "Bob", "Draw"]

if a > b:
    if a == 13 and b == 1:
        idx = 1
    else:
        idx = 0
elif a < b:
    if a == 1 and b == 13:
        idx = 0
    else:
        idx = 1
else:
    idx = 2

print(l[idx])
//  [python]
a, b = map(int, input().split())

if a==1:
    a = 14
if b==1:
    b = 14

if a>b:
    print("Alice")
elif a<b:
    print("Bob")
else:
    print("Draw")
//  [python]
a, b = map(int, input().split())

if a == 1:
    a = 14

if b == 1:
    b = 14

print(a, b)

if a < b:
    print("Bob")
elif b < a:
    print("Alice")
else:
    print("Draw")
//  [python]
a, b = map(int, input().split())

if a == 1:
    a = 14
    
if b == 1:
    b == 14

if a < b:
    print("Bob")
elif b < a:
    print("Alice")
else:
    print("Draw")
//  [python]
a, b = map(int, input().split())

if a == 1:
    a = 14
elif b == 1:
    b == 14

if a < b:
    print("Bob")
elif b < a:
    print("Alice")
else:
    print("Draw")
//  [java]
import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		
		// 入力
		int a = sc.nextInt();
		int b = sc.nextInt();
		
		// 計算
		String result = "Alice";
		if(a == b){
		    result = "Draw";
		}else{
		    if(b == 1 || (a < b && a != 1)) result = "Bob";
		}
		
		
		// 出力
		System.out.println(result);
	}
	
	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}
//  [java]
import java.io.*;
import java.util.*;
class Main{
	static final long MOD = 1_000_000_007; // 10^9+7
    static final int MAX = 2_147_483_646; // intMax 
    static final int INF = 1_000_000_000; // 10^9  
    public static void main(String[] args) throws Exception {
		hayami saori = new hayami();
		int a = saori.saori_hayami();
		int b = saori.saori_hayami();
		if(a == 1){
			a = 14;
		}
		if(b == 1){
			b = 14;
		}
		if(a == b){
			System.out.println("Draw");
		} else if(a > b){
			System.out.println("Alice");
		}else if(a < b){
			System.out.println("Bob");
		}
		saori.close();
    }
}

class hayami implements Closeable {
	private final InputStream in = System.in;
	private final byte[] hayami = new byte[1024];
	private int Hayami = 0;
	private int saori = 0;
	private boolean HayamiSaori() {
		if (Hayami < saori) {
			return true;
		}else{
			Hayami = 0;
			try {
				saori = in.read(hayami);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (saori <= 0) {
				return false;
			}
		}
		return true;
	}
	private int SaoriHayami() { 
		if (HayamiSaori()) {
            return hayami[Hayami++];
         }else{
             return -1;
         }
	}
	private static boolean hayami_saori(int hayami) { 
		return 33 <= hayami && hayami <= 126;
	}
	public boolean hayamisaori() { 
		while(HayamiSaori() && !hayami_saori(hayami[Hayami])) Hayami++; return HayamiSaori();
	}
	public String nextHayami() {
		if (!hayamisaori()) throw new NoSuchElementException();
		StringBuilder hayamin = new StringBuilder();
		int saori = SaoriHayami();
		while(hayami_saori(saori)) {
			hayamin.appendCodePoint(saori);
			saori = SaoriHayami();
		}
		return hayamin.toString();
	}
	public long saorihayami() {//nextLong
		if (!hayamisaori()) throw new NoSuchElementException();
		long hayami = 0;
		boolean misao = false;
		int saori = SaoriHayami();
		if (saori == '-') {
			misao = true;
			saori = SaoriHayami();
		}
		if (saori < '0' || '9' < saori) {
			throw new NumberFormatException();
		}
		while(true){
			if ('0' <= saori && saori <= '9') {
				hayami *= 10;
				hayami += saori - '0';
			}else if(saori == -1 || !hayami_saori(saori)){
				return misao ? -hayami : hayami;
			}else{
				throw new NumberFormatException();
			}
			saori = SaoriHayami();
		}
	}
	public int saori_hayami() {//nextInt
		long hayami = saorihayami();
		if (hayami < Integer.MIN_VALUE || hayami > Integer.MAX_VALUE) throw new NumberFormatException();
		return (int) hayami;
	}
	public double Hayamin() { //nextDouble
		return Double.parseDouble(nextHayami());
	}
	public void close() {
		try {
			in.close();
		} catch (IOException e) {
		}
    }
    
}
//  [java]
import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		// 整数の入力
        int a = sc.nextInt();
     	int b = sc.nextInt();
      
        if(a == b ){
          System.out.println("Draw");
        }else if(a > b && b != 1){
          System.out.println("Alice");
        }else if(a < b && a != 1){
          System.out.println("Bob");
        }else{
          System.out.println("Alice");
        }
    }
}
//  [java]
import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		// 整数の入力
        int a = sc.nextInt();
     	int b = sc.nextInt();
      
        if(a == b ){
          System.out.println("Draw");
        }else if(a > b && b != 1){
          System.out.println("Alice");
        }else{
          System.out.println("Bob");
        }
    }
}
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		sc.close();

		if (a == b) {
			System.out.println("Draw");
			return;
		}

		if (a == 1) {
			System.out.println("Alice");
			return;
		}

		if (b == 1) {
			System.out.println("Alice");
			return;
		}

		if (a > b) {
			System.out.println("Alice");
			return;
		}

		System.out.println("Bob");

	}

}
//  [cpp]
#include <cstdio>
#include <vector>
#include <algorithm>
#include <functional>
#include <tuple>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <array>
#include <utility>
#include <valarray>

using namespace std;

int main()
{
    int A, B;
    scanf("%d %d\n", &A, &B);
    if (A == 1) A = 14;
    if (B == 1) B = 14;
    if (A > B){
        puts("Alice");
    }else if (A < B){
        puts("Bob");
    }else{
        puts("Draw");
    }
}
//  [cpp]
#include <stdio.h>

int main()
{
	int a,b;
	scanf("%d%d",&a,&b),a=(a+11)%13+1,b=(b+11)%13+1;
	printf("%s\n",a>b ? "Alice" : a==b ? "Draw" : "Bob");
}
//  [cpp]
#include<cmath>
#include<cstdio>
#include<cassert>
#include<cstring>
#include<algorithm>
#define MN 51
#define Cx 0.03
#define Cy 0.03
#define eps 1e-7
using namespace std;

int read_p,read_ca;
inline int read(){
    read_p=0;read_ca=getchar();
    while(read_ca<'0'||read_ca>'9') read_ca=getchar();
    while(read_ca>='0'&&read_ca<='9') read_p=read_p*10+read_ca-48,read_ca=getchar();
    return read_p;
}
int n,m;
int main(){
	register int i;
	n=read();m=read();
	if (n==1) n=14;
	if (m==1) m=14;
	if (n<m) puts("Bob");else if (n==m) puts("Draw");else puts("Alice");
}
//  [cpp]
/*
 ▓█████▄  ▄████▄  ▓██   ██▓ ██▓███   ██░ ██ ▓█████  ██▀███
▒██▀ ██▌▒██▀ ▀█   ▒██  ██▒▓██░  ██▒▓██░ ██▒▓█   ▀ ▓██ ▒ ██▒
 ░██   █▌▒▓█    ▄   ▒██ ██░▓██░ ██▓▒▒██▀▀██░▒███   ▓██ ░▄█ ▒
 ░▓█▄   ▌▒▓▓▄ ▄██▒  ░ ▐██▓░▒██▄█▓▒ ▒░▓█ ░██ ▒▓█  ▄ ▒██▀▀█▄
 ░▒████▓ ▒ ▓███▀ ░  ░ ██▒▓░▒██▒ ░  ░░▓█▒░██▓░▒████▒░██▓ ▒██▒
  ▒▒▓  ▒ ░ ░▒ ▒  ░   ██▒▒▒ ▒▓▒░ ░  ░ ▒ ░░▒░▒░░ ▒░ ░░ ▒▓ ░▒▓░
  ░ ▒  ▒   ░  ▒    ▓██ ░▒░ ░▒ ░      ▒ ░▒░ ░ ░ ░  ░  ░▒ ░ ▒░
  ░ ░  ░ ░         ▒ ▒ ░░  ░░        ░  ░░ ░   ░     ░░   ░
    ░    ░ ░       ░ ░               ░  ░  ░   ░  ░   ░
  ░      ░         ░ ░
*/
//focus less on how much problem you should solve within a fixed time and focus more on getting the problem solved and
//learning something from it
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define rep(i,a,b) for(ll i=a; i<b; i++)
#define per(i,a,b) for(ll i=a; i>=b; i--)
#define ll long long int
#define ld long double
#define vi vector<ll>
#define pi pair<ll,ll>
#define vii vector <pair<ll,ll> >
#define sedes set <ll, greater <ll> >
#define seasc set <ll>
#define pb push_back
#define mkp make_pair
#define ff first
#define ss second
#define MOD 1000000007
#define prec(n) fixed<<setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define umap unordered_map<ll, ll>
#define map map<ll, ll>
#define autoit(x,it) for(auto it = x.begin(); it != x.end(); it++)
#define mems(a, i) memset(a, i, sizeof(a))
#define endl '\n'
#define all(v) v.begin(),v.end()
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/gcd((a),(b))
#define deba(a) cout << #a << " " <<a << endl;
int main()
{
	fast;
#ifndef ONLINE_JUDGE
	freopen("D:\\input.txt", "r", stdin);
	freopen("D:\\output.txt", "w", stdout);
#endif
	int t = 1;
	// cin >> t;
	while (t--)
	{
		ll n, m;
		cin >> n >> m;
		if (n == m)
			cout << "Draw";
		else if (n > m and m != 1)
			cout << "Alice";
		else if (m > n or m == 1)
			cout << "Bob";
	}
	return 0;
}
//  [cpp]
/*
 ▓█████▄  ▄████▄  ▓██   ██▓ ██▓███   ██░ ██ ▓█████  ██▀███
▒██▀ ██▌▒██▀ ▀█   ▒██  ██▒▓██░  ██▒▓██░ ██▒▓█   ▀ ▓██ ▒ ██▒
 ░██   █▌▒▓█    ▄   ▒██ ██░▓██░ ██▓▒▒██▀▀██░▒███   ▓██ ░▄█ ▒
 ░▓█▄   ▌▒▓▓▄ ▄██▒  ░ ▐██▓░▒██▄█▓▒ ▒░▓█ ░██ ▒▓█  ▄ ▒██▀▀█▄
 ░▒████▓ ▒ ▓███▀ ░  ░ ██▒▓░▒██▒ ░  ░░▓█▒░██▓░▒████▒░██▓ ▒██▒
  ▒▒▓  ▒ ░ ░▒ ▒  ░   ██▒▒▒ ▒▓▒░ ░  ░ ▒ ░░▒░▒░░ ▒░ ░░ ▒▓ ░▒▓░
  ░ ▒  ▒   ░  ▒    ▓██ ░▒░ ░▒ ░      ▒ ░▒░ ░ ░ ░  ░  ░▒ ░ ▒░
  ░ ░  ░ ░         ▒ ▒ ░░  ░░        ░  ░░ ░   ░     ░░   ░
    ░    ░ ░       ░ ░               ░  ░  ░   ░  ░   ░
  ░      ░         ░ ░
*/
//focus less on how much problem you should solve within a fixed time and focus more on getting the problem solved and
//learning something from it
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define rep(i,a,b) for(ll i=a; i<b; i++)
#define per(i,a,b) for(ll i=a; i>=b; i--)
#define ll long long int
#define ld long double
#define vi vector<ll>
#define pi pair<ll,ll>
#define vii vector <pair<ll,ll> >
#define sedes set <ll, greater <ll> >
#define seasc set <ll>
#define pb push_back
#define mkp make_pair
#define ff first
#define ss second
#define MOD 1000000007
#define prec(n) fixed<<setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define umap unordered_map<ll, ll>
#define map map<ll, ll>
#define autoit(x,it) for(auto it = x.begin(); it != x.end(); it++)
#define mems(a, i) memset(a, i, sizeof(a))
#define endl '\n'
#define all(v) v.begin(),v.end()
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/gcd((a),(b))
#define deba(a) cout << #a << " " <<a << endl;
int main()
{
	fast;
#ifndef ONLINE_JUDGE
	freopen("D:\\input.txt", "r", stdin);
	freopen("D:\\output.txt", "w", stdout);
#endif
	int t = 1;
	// cin >> t;
	while (t--)
	{
		ll n, m;
		cin >> n >> m;
		if (n > m and m != 1)
			cout << "Alice";
		else if (m > n or m == 1)
			cout << "Bob";
		else
			cout << "Draw";
	}
	return 0;
}
//  [cpp]
#include<stdio.h>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<set>
 
#define Vsort(a) sort(a.begin(), a.end())
#define Vreverse(a) reverse(a.begin(), a.end())
#define Srep(n) for(int i = 0; i < (n); i++)
#define Lrep(i,a,n) for(int i = (a); i < (n); i++)
#define Brep(n) for(int bit = 0; bit < (1<<n); bit++)
#define rep2nd(n,m) Srep(n) Lrep(j,0,m)
#define vi vector<int>
#define vi64 vector<int64_t>
#define vvi vector<vector<int>>
#define vvi64 vector<vector<int64_t>>
#define P pair<int,int>
#define F first
#define S second
 
using namespace std;

int main(){
  int a,b;
  cin >> a >> b;
  if(a == b){
    cout << "Drow" << endl;
    return 0;
  }
  if(a == 1){
    cout << "Alice" << endl;
    return 0;
  }
  if(b == 1){
    cout << "Bob" << endl;
    return 0;
  }
  cout << (a > b ? "Alice" : "Bob") << endl;
}
//  [c]
#include <stdio.h>

int main(void) {
	int A, B;
	if (scanf("%d%d", &A, &B) != 2) return 1;
	if (A == 1) A = 999;
	if (B == 1) B = 999;
	puts(A > B ? "Alice" : (A < B ? "Bob" : "Draw"));
	return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    int ans=0;
    int a,b;
    scanf("%d %d",&a,&b);
    if(a==1){
        a=100;
    }
    if(b==1){
        b=100;
    }
    if(a>b){
        printf("Alice\n");
    }else if(a<b){
        printf("Bob\n");
    }else{
        printf("Draw\n");
    }
    
    
    return 0;
}
//  [c]
#include <stdio.h>

int main(int argc, char const *argv[]) {
  int a, b;

  scanf("%d", &a);
  if(a == 1)
    a = 14;
  scanf("%d", &b);
  if(b == 1)
    b = 14;

  if (a > b)
    printf("Alice\n");
  else if(a == b)
    printf("Draw\n");
  else
    printf("Bob\n");

  return 0;
}
//  [c]
#include <stdio.h>

int main () {
	int a, b;
	scanf("%d %d", &a, &b);
	if (a == b) {
		puts("Draw");
	}	
	else if (b >= 13) {
		puts("Alice");
	}
	else if (a >= 13) {
		puts("Bob");
	}
	else if (a > b) {
		puts("Alice");
	}
	else {
		puts("Bob");
	}
	return 0;
}
//  [c]
#include <stdio.h>

int main () {
	int a, b;
	scanf("%d %d", &a, &b);
	if (b >= 13) {
		puts("Alice");
	}
	else if (a >= 13) {
		puts("Bob");
	}
	else if (a > b) {
		puts("Alice");
	}
	else if (b > a) {
		puts("Bob");
	}
	else {
		puts("Draw");
	}
	return 0;
}
//  [c]
#include <iostream>
#include <bits/c++io.h>
#include <algorithm>
#include <iomanip>
#include <math.h>
using namespace std;

int main()
{
 int x,y;
 cin>>x>>y;
if(x==y)
    cout<<"Draw"<<endl;
  else  if(x==1) cout<<"Alice"<<endl;
  else  if(y==1) cout<<"Bob"<<endl;
  else {
      if(x>y) cout<<"Alice"<<endl;
      else cout<<"Bob"<<endl;

      }

}
//  [javascript]
"use strict";
const Main = (input) => {
	let xs = input.trim().split(' ').map(v=>parseInt(v,10));
    let ans0 = xs[0];
    let ans1 = xs[1];

    if(xs[0] == 1){
    	ans0 = xs[0] + 13;
    }
   
    if(xs[1] == 1){
        ans1 = xs[1] + 13;
    }       
     
    if(ans0 == ans1){
        console.log('Draw');
    }else if(ans0 > ans1){
        console.log('Alice');
    }else{
    	console.log('Bob');
    }
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [javascript]
'use strict'

function main(s) {

  s = s.split('\n')[0].split(' ').map(n => Number(n));

  let a = s[0];
  let b = s[1];

  if (a === 1) a += 13;
  if (b === 1) b += 13;

  let ans = '';

  if (a > b)   ans = 'Alice';
  if (a < b)   ans = 'Bob';
  if (a === b) ans = 'Draw';

  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input){
    var A = parseInt(input.split("\n")[0].split(" ")[0]);
    var B = parseInt(input.split("\n")[0].split(" ")[1]);
    
    if(A == 1) A = 14;
    if(B == 1) B = 14;
    
    if(A == B) {
        console.log("Draw");
    } else if(A > B) {
        console.log("Alice")
    } else {
        console.log("Bob")
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
  var args = input.split(" ");
  var A = parseInt(args[0]),
      B = parseInt(args[1]);
  
  if (A == 1)
    A = 14;
  if (B == 1)
    B = 14;
  cobsole.log(A == B ? "Draw" : A > B ? "Alice" : "Bob");
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input){
  var args = input.split(" ");
  var A = parseInt(args[0]),
      B = parseInt(args[1]);
  
  if (A == 1)
    A = 14;
  if (B == 1)
    B = 14;
  cobsole.log(a == b ? "Draw" : a > b ? "Alice" : "Bob");
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main (input){
  var args = input.split(" ");
  var A = parseInt(args[0]),
      B = parseInt(args[1]);
  
  if (A == 1)
    A = 14;
  if (B == 1)
    B == 14;
  
  if (A == B){
    console.log("Draw");
  }else if (A > B){
    console.log("Alice");
  }else{
    console.log("Bob")
  }
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
// +build ignore
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

// I/O
type Scanner struct {
	sc *bufio.Scanner
}

func NewScanner() *Scanner {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 1024), int(1e+9))
	return &Scanner{sc}
}

func (s *Scanner) nextStr() string {
	s.sc.Scan()
	return s.sc.Text()
}

func (s *Scanner) nextInt() int {
	i, e := strconv.Atoi(s.nextStr())
	if e != nil {
		panic(e)
	}
	return i
}

func (s *Scanner) nextFloat() float64 {
	f, e := strconv.ParseFloat(s.nextStr(), 64)
	if e != nil {
		panic(e)
	}
	return f
}

func (s *Scanner) nextRuneSlice() []byte {
	return []byte(s.nextStr())
}

func (s *Scanner) nextIntSlice(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = s.nextInt()
	}
	return res
}

func (s *Scanner) nextFloatSlice(n int) []float64 {
	res := make([]float64, n)
	for i := 0; i < n; i++ {
		res[i] = s.nextFloat()
	}
	return res
}

func gcd(x, y int) int {
	if x%y != 0 {
		return gcd(y, x%y)
	}
	return y
}

func run(input io.Reader, output io.Writer) int {
	sc := NewScanner()
	A := sc.nextInt()
	B := sc.nextInt()

	if A == 1 {
		A = 14
	}

	if B == 1 {
		B = 14
	}

	switch {
	case A > B:
		fmt.Println("Alice")
	case A < B:
		fmt.Println("Bob")
	default:
		fmt.Println("Draw")
	}

	return 0
}

func main() {
	os.Exit(run(os.Stdin, os.Stdout))
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)

	if a == 1 {
		a = 14
	}
	if b == 1 {
		b = 14
	}

	if a == b {
		fmt.Println("Draw")
	} else if a > b {
		fmt.Println("Alice")
	} else {
		fmt.Println("Bob")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)

	if a == b {
		fmt.Println("Draw")
	} else if (a != 1 && a > b) || a == 1 {
		fmt.Println("Alice")
	} else {
		fmt.Println("Bob")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)

	if a == b {
		fmt.Println("Draw")
	} else if a > b || a == 1 {
		fmt.Println("Alice")
	} else {
		fmt.Println("Bob")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scanf("%d %d", &a, &b)
	if a > b {
		fmt.Println("Alice")
	} else if  a < b {
    fmt.Println("Bob")
	} else {
		fmt.Println("Draw")
	}
}
//  [ruby]
x,y = gets.chomp.split.map(&:to_i)
cards_force = [2,3,4,5,6,7,8,9,10,11,12,13,1]
a = cards_force.index(x)
b = cards_force.index(y)

if a < b
  puts "Bob"
elsif a == b
  puts "Draw"
else
  puts "Alice"
end
//  [ruby]
m=gets.split.map(&:to_i)
m=m.map{|n|n==1 ?n=14:n=n}
puts
if m[0]>m[1]
    puts "Alice"
elsif m[0]==m[1]
    puts "Draw"
else
   puts "Bob"
end
//  [ruby]
a, b = gets.split(" ").map(&:to_i)
a = (a == 1 ? 14 : a)
b = (b == 1 ? 14 : b)
puts a > b ? "Alice" : (a == b ? "Draw" : "Bob")
//  [ruby]
n,m = gets.strip.split.map(&:to_i)
if n==1
  n = 14
end
if m==1
  m = 14
end
if n < m
  puts "Bob"
elif n == m
  puts "Draw"
else
  puts "Alice"
end
//  [ruby]
a,b=gets.split.map do |i|
  return 14 if i.to_i == 1
  i.to_i
end
puts a==b ? "Draw" : [a,b].sort==[a,b] ? "Bob" : "Alice"
//  [ruby]
a,b=gets.split.map do |i|
  i.to_i
  14 if i.to_i == 1
end
puts a==b ? "Draw" : [a,b].sort==[a,b] ? "Bob" : "Alice"
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let mut a = v[0];
	let mut b = v[1];
	if a == 1 {
		a += 13;
	}
	if b == 1 {
		b += 13;
	}
	if a < b {
		println!("Bob");
	}else if a > b {
		println!("Alice");
	}else{
		println!("Draw");
	}
}
//  [rust]
//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//https://github.com/manta1130/Competitive_Programming_Template_Rust

#[macro_use]
mod input {

    use std;
    use std::io;

    const SPLIT_DELIMITER: char = ' ';

    #[macro_export]
    #[allow(unused_macros)]
    macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

    #[allow(dead_code)]
    pub fn input_line_str() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn p<T>(t: T)
    where
        T: std::fmt::Display,
    {
        println!("{}", t);
    }

    #[allow(dead_code)]
    pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<Vec<T>> = Vec::new();

        for _ in 0..line {
            let vec_line = input_vector();
            v.push(vec_line);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector<T>() -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<T> = Vec::new();

        let s = input_line_str();
        let split_result = s.split(SPLIT_DELIMITER);
        for z in split_result {
            let buf = match z.parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector_row<T>(n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            let buf = match input_line_str().parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    pub trait ToCharVec {
        fn to_charvec(&self) -> Vec<char>;
    }

    impl ToCharVec for String {
        fn to_charvec(&self) -> Vec<char> {
            self.to_string().chars().collect::<Vec<_>>()
        }
    }
}

use input::*;
use std::cmp::Ordering;

fn main() {
    let (mut a, mut b): (usize, usize);
    input!(a, b);
    if a == 1 {
        a = 99;
    }
    if b == 1 {
        b = 99;
    }
    println!(
        "{}",
        match a.cmp(&b) {
            Ordering::Greater => "Alice",
            Ordering::Less => "Bob",
            _ => "Draw",
        }
    );
}
//  [rust]
use std::io::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn main() {
    let a: i32 = read();
    let b: i32 = read();

    if a == b {
        println!("Draw");
        return;
    }

    if a == 1 {
        println!("Alice");
        return;
    }
    if b == 1 {
        println!("Bob");
        return;
    }
    println!("{}", if a > b { "Alice" } else { "Bob" })
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        a: i32,
        b: i32,
    }

    let answer = if a < b {
        "Alice"
    } else if a > b {
        "Bob"
    }else{
 		 "Draw"
  	};
    println!("{}", answer)
}
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());
    assert_eq!(!0usize, std::usize::MAX); //🙊

    let (a,b) = (io.read::<i64>(),io.read::<i64>());

    if a==b {
        io.writeln("Draw");
    }
    if a == 1 || a > b{
        io.writeln("Alice");
    }else {
        io.writeln("Bob");}


}

static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let a: usize = read();
    let b: usize = read();
    if a == b {
        println!("Draw");
        return;
    }

    if a == 1 || a > b {
        println!("Alice");
        return;
    }

    if b == 1 || b > a {
        println!("Bob");
        return;
    }
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!}.map{$0>1 ?$0:14};print(i[0]>i[1] ?"Alice":(i[0]<i[1] ?"Bob":"Draw"))
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!}.map{$0>1 ?$0:14};print(i[0]-i[1]>0 ?"Alice":(i[0]-i[1]<0 ?"Bob":"Draw"))