Problem:
Score : 100 points

Problem Statement

Given are three integers A_1, A_2, and A_3.

If A_1+A_2+A_3 is greater than or equal to 22, print bust; otherwise, print win.

Constraints

1 \leq A_i \leq 13 \ \ (i=1,2,3)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A_1 A_2 A_3

Output

If A_1+A_2+A_3 is greater than or equal to 22, print bust; otherwise, print win.

Sample Input 1

5 7 9

Sample Output 1

win

5+7+9=21, so print win.

Sample Input 2

13 7 2

Sample Output 2

bust

13+7+2=22, so print bust.

Solution in Rust (1.15.1) (judge verdict: Runtime Error)


fn main_() {
    assert_eq!(solve("2 2\n1 2\n3 4\n3 4\n2 1\n"), "0\n");
    assert_eq!(solve("2 3\n1 10 80\n80 10 1\n1 2 3\n4 5 6\n"), "2\n");
}

fn solve(src: &str) -> String {
    let mut sc = Scanner::from_str(src);

    let h: usize = sc.read();
    let w: usize = sc.read();
    let m = 80*(h+w-1)+1;
    let a: Vec<Vec<usize>> = (0..h)
        .map(|_| (0..w).map(|_| sc.read()).collect())
        .collect();
    let b: Vec<Vec<usize>> = (0..h)
        .map(|_| (0..w).map(|_| sc.read()).collect())
        .collect();
    let mut dp = vec![vec![vec![false;m]; w]; h]; 
    
    dp[0][0][dif(a[0][0],b[0][0])] = true;
    for i in 0..h {
      for j in 0..w {
        let p = dif(a[i][j],b[i][j]);
        for d in 0..m {
          if (i>0 && dp[i-1][j][d])||(j>0 && dp[i][j-1][d]) {
            dp[i][j][d+p] = true;
            dp[i][j][dif(d,p)] = true;
          }
        }
      }
    }
    
    for scr in 0..m {
      if dp[h-1][w-1][scr] {
        return format!("{}\n", scr);
      }
    }
    "".to_string()
}

fn dif(a: usize, b: usize) -> usize {
  if a > b {
    a - b
  } else {
    b - a
  }
}

fn main() {
    let mut buf = String::new();
    use std::io;
    use std::io::{Read, Write};
    io::stdin().read_to_string(&mut buf).unwrap();
    io::stdout().write_all(solve(&buf).as_bytes()).unwrap();
}

struct Scanner<'a>(std::str::SplitWhitespace<'a>);
impl<'a> Scanner<'a> {
    fn from_str(src: &str) -> Scanner {
        Scanner(src.split_whitespace())
    }
    fn get(&mut self) -> &str {
        self.0.next().unwrap()
    }
    fn read<T: std::str::FromStr>(&mut self) -> T {
        self.get().parse().ok().unwrap()
    }
}