jiahuimbzuai/CoQuIR huggingface dataset:
//  [swift]
let NT: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
var res = Int(1e5)
var can = false
for _ in 1...NT[0] {
    let ct: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
    if ct[1] <= NT[1] {
        can = true
        res = min(res, ct[0])
    }
}
print(can ? res : "TLE") // (๑•ૅㅁ•๑)
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    func count() -> Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
}
extension Array where Element: Comparable {
    func max() -> Element! {
        return self.maxElement()
    }
    func min() -> Element! {
        return self.minElement()
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let input = readIntSplit(by: " ")
let (N, T) = (input[0], input[1])
var ans = 10000
for _ in 0..<N {
    let input = readIntSplit(by: " ")
    let (c, t) = (input[0], input[1])
    if t <= T {
        ans = min(ans, c)
    }
}
print(ans>1000 ? "TLE" : ans)
//  [swift]
let NT: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
var res: Int = Int(1e9)
for _ in 1...NT[0] {
  let ct: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
  res = ct[1] > NT[1] ? res : min(res, ct[0])
}
print(res != 0 ? res : "TLE")
//  [swift]
let NT: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
var res: Int = 1e9
for _ in 1...NT[0] {
  let ct: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
  res = ct[1] > NT[1] ? res : min(res, ct[0])
}
print(res != 0 ? res : "TLE")
//  [swift]
let NT: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
var res: Int = 0
for _ in 1...NT[0] {
  let ct: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
  res = ct[1] > NT[1] ? res : min(res, ct[0])
}
print(res != 0 ? res : "TLE")
//  [typescript]
const main = (input) => {
  const lines = input.trim().split("\n");
  const [N, T] = lines[0].split(' ').map(x => parseInt(x));
  let minCost = 10000;
  lines.slice(1).forEach(line => {
    const [c, t] = line.split(' ').map(str => parseInt(str));
    if (t <= T && c < minCost) {
      minCost = c;
    }
  });

  if (minCost === 10000) {
    console.log('TLE');
  } else {
    console.log(minCost);
  }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [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):any=>{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):any=>{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=()=>{
  let [a,b]=t.s(2)
  let c=[],d=[],l=1001
  for(let i=0;i<a;i++){
    c.push(t.n())
    d.push(t.n())
  }
  for(let i=0;i<a;i++){
    if(d[i]<=b&&l>c[i]){
      l=c[i]
    }
  }
  t.o(l==1001?'TLE':l)
}
main()
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [n, t] = stdin
  .split('\n')[0]
  .split(' ')
  .map(Number)

const [, ...ct] = stdin
  .trim()
  .split('\n')
  .map(e => e.split(' ').map(Number))

const filtered = ct.filter(e => e[1] <= t)

const ans = _ => {
  if(filtered.length <= 0){
    return 'TLE'
  }

  return Math.min(...filtered.map(e=>e[0]))
}

console.log(ans())
//  [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):any=>{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):any=>{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=()=>{
  let [a,b]=t.s(2)
  let c=[],d=[],l=1001
  for(let i=0;i<a;i++){
    c.push(t.n())
    d.push(t.n())
  }
  for(let i=0;i<a;i++){
    if(d[i]<b&&l>c[i]){
      l=c[i]
    }
  }
  t.o(l==1001?'TLE':l)
}
main()
//  [python]
s = input()
t = input()
count = 0
for id in range(3):
    if s[id] == t[id]: count += 1
else: print(count)
//  [python]
s = input()
t = input()

ans = 0
for ss, tt, in zip(s, t):
    if ss==tt:
        ans+=1
print(ans)
//  [python]
tenkikyohou = input()
tenki = input()

ans = 0

for i in range(3):
    if tenkikyohou[i] == tenki[i]:
        ans += 1

print(ans)
//  [python]
S = list(input())
T = list(input())
c = 0
for i in range(2):
    if S[i] == T[i]:
        c += 1
print(c)
//  [python]
s = input()
t = input()
ans = 0

for i in range(s):
  ans += s[i] == t[i]

print(ans)
//  [python]
s = int(input())
t = int(input())
count = 0
for i in range(len(s)):
    if s[i] == t[i]:
        count += 1
        
print(count)
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {
	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		String S = sc.next();
		String T = sc.next();
		int ans = 0;
		for (int i = 0; i < 3; i++) {
			if (S.charAt(i) == T.charAt(i)) ans++;
		}
		System.out.println(ans);
	}

}

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());
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	
	public static void main(String[] args) throws IOException {
		Main mainObj = new Main();
		mainObj.solve();
	}

	public void solve() throws IOException {
		FastScanner fs = new FastScanner();
		String s = fs.next();
		String t = fs.next();
		
		int ans = 0;
		for(int i = 0; i < s.length(); i++) {
			char sAt = s.charAt(i);
			char tAt = t.charAt(i);
			if(sAt == tAt) {
				ans++;
			}
		}
		
		System.out.println(ans);
	}

	

	public class FastScanner {

		BufferedReader reader;
		private StringTokenizer st;

		public FastScanner() {
			st = null;
			reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() throws IOException {
			if (st == null || !st.hasMoreElements()) {
				st = new StringTokenizer(reader.readLine());
			}
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			st = null;
			String readLine = null;
			readLine = reader.readLine();
			return readLine;
		}

		public int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(next());
		}

		public int[] nextIntArr(int n) throws NumberFormatException, IOException {
			int[] retArr = new int[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextInt();
			}
			return retArr;
		}

		public long[] nextLongArr(int n) throws NumberFormatException, IOException {
			long[] retArr = new long[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextLong();
			}
			return retArr;
		}

		public void close() throws IOException {
			reader.close();
		}
	}


}
//  [java]

import java.util.ArrayList;
import java.util.Scanner;


public class Main {
public static void main (String[] args){


	Scanner sc =new Scanner(System.in);
	ArrayList<String> list=new ArrayList<String>();

	while(sc.hasNext()) {
		list.add(sc.next());
	}


	int i=0;
	
	if(list.get(0)==list.get(3)) i++;
	if(list.get(1)==list.get(4)) i++;
	if(list.get(2)==list.get(5)) i++;

	System.out.print(i);

}
}
//  [java]
import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner sc =new Scanner(System.in);
    String S =sc.next();
    String s[] =S.split("",0);
    String T =sc.next();
    String t[] =T.split("",0);
    int ans=0;
    for(int i=0;i<3;i++){
      if(s[i].equals(t[i])){ans =ans+1;}}
    System.ouut.println(ans);
  }
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{
    string m,d;
    int count = 0;
    cin >> m; 
    cin >> d;
    for(int i = 0;i<3;i++){
        if(m[i]==d[i]){
            count++;
        }
    }
    cout << count;

}
//  [cpp]
#include <iostream>
using namespace std;

int main() {
	char y[4], z[4];
	int count = 0;
	for (int i = 0; i < 3; i++) {
		cin >> y[i];
	}
	for (int i = 0; i < 3; i++) {
		cin >> z[i];
	}
	for (int i = 0; i < 3; i++) {
		if (y[i] == z[i]) {
			count++;
		}
	}
	cout << count << endl;
	return 0;

}
//  [cpp]
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <math.h>

using namespace std;

int main(void){
    string s, t;
    cin >> s >> t;
    int res = 0;

    for(int i = 0; i < (int)s.size(); i++){
        char ch1 = s[i];
        char ch2 = t[i];
        if(ch1 == ch2){
            res++;
        }
    }

    cout << res << endl;

    return 0;
}
//  [cpp]
/*
    -ensure correct output format
    -ensure printing required output
    -reread the problem statement
  */

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c)   min(a, min(b, c))
#define max3(a, b, c)   max(a, max(b, c))
#define F first
#define S second
#define in  freopen("input.txt", "r", stdin)
#define out  freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x)  (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI  =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
       return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
    if(a==0 || b==0)return 0;

    return a/__gcd(a,b)*b;
}

void input(ll ara[],ll n)
{
    for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
    for(ll i=0; i<n; i++)
        cout<<ara[i]<<" ";
    cout<<endl;
}


int main()
{

   fastread();

   ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;

      bool flag=false;

      string str,ptr;


   cin>>a>>b;

   if(b==1)
   {
       cout<<0<<endl;

       return 0;
   }

   sum=a;

   cnt=1;

   while(sum<b)
   {
       sum+=(a-1);

       cnt++;
   }

   cout<<cnt<<endl;


}
//  [cpp]
#include <iostream>
#include <string>

int main() {
  std::string s(3), t(3);
  std::cin >> s >> t;
  int ans = 0;
  for (int i = 0; i < 3; ++i) ans += (s[i] == t[i]);
  std::cout << ans << std::endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
  vector<char>vec(3);
  for(ll i=0;i<3;i++){
    cin>>vec.at(i);
  }
  ll a=0;
  for(ll i=0;i<3;i++){
    char d;
    cin>>d;
    if(vec.at(i)==d){
      a+=1;
    }
  }
  cour<<a<<endl;
  return 0;
}
//  [c]
#include <stdio.h>

int main() {
	char s[4];
	char t[4];
	int i, ans = 0;

	scanf("%s", s);
	scanf("%s", t);

	for (i = 0; i < 3; i++) {
		if (s[i] == t[i]) {
			ans++;
		}
	}

	printf("%d\n", ans);
	

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

int main (void) {
  char S[4], T[4];
  int i;
  int a = 0;

  scanf ("%s", S);
  scanf ("%s", T);

  for (i = 0; i < 3; i++) {
    if (S[i] == T[i]) {
      a++;
    }
  }

  printf ("%d", a);
}
//  [c]
#include <stdio.h>
 
int main(void){
 
  char S[4], T[4];
  int i, count;
 
  scanf("%s", &S);
  scanf("%s", &T);
  for(i = 0; i <= 2 ;i++)
  {
    if(S[i] == T[i])
    count++;
  }
  printf("%d", count);
return 0;
}
//  [c]
#include<stdio.h>

int main(void){
  char s[5],t[5];
  scanf("%s",s);
  scanf("%s",t);
  int c=0;
  for(int i=0;i<sizeof(s);i++){
    if(s[i]==t[i]){
      c++;
    }
  }
  
  printf("%d",c);
  return 0;
}
//  [c]
#include<stdio.h>

int main(void){
    char s[4], t[4];
    int i, n;

    scanf("%s%s",s,t);
    i=0;    n=0;
    while(s[i] != '\0'){
        if(s[i] == t[i]){
            n++;
        }
        i++;
    }
    printf("%d\n");
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    char S[4],n[4];
    int i,j=0;
  
    scanf("%s%s",S,n);
  
    for(i=0;i<3;i++){
      if(S[i]==n[i]) j++;
    }
      
    printf("%d\n",j);
//  [javascript]
function Main(input) {
    input = input.trim()
  input = input.split("\n");
  var A = input[0].split("");
  var B = input[1].split("");
  var sum = 0;
  if(A[0]==B[0]) sum++;
  if(A[1]==B[1]) sum++;
  if(A[2]==B[2]) sum++;
  console.log(sum)
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	var ST = input.split("\n");
	var S = ST[0].split("");
	var T = ST[1].split("");
	
	var cnt = 0;
	for (var i = 0; i < S.length; i++){
		if (S[i] === T[i]) {
			cnt++;
		}
	}
	
	console.log(cnt);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const Main = (input) => {
const dataArray = input.split('\n');
const forecast = dataArray[0];
const weather = dataArray[1];
var hit = 0;
  for(var i = 0; i < 3; i++){
  	if(forecast[i] == weather[i]){
      hit += 1;
    }
  }
  console.log(hit);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    var array = input.split(" ");
    var a = parseInt(array[0]);
    var b = parseInt(array[1]);
    var calc = Math.floor(b / a);
    if (b%a !== 0){
        calc++;
    }
    console.log(calc);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
   input = input.trim();
  const inp = input.split("\n");
  const a = inp[0].split(" ");
  const b = inp[1].split(" ");
  var ans = 0;
  for ( i = 0; i < 3; i++) {
	if (a[i]==b[i]) {
		ans++;
		}
    }
  console.log(ans);
  
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const Main = (input) => {
    a = input.split('\n')
    b = a[0].split('')
    c = a[1].split('')
    n = 0
    for (let index = 0; index < b.length; index++) {
        if (b[index] == c[index]) {n += 1} 
    }
    console.log(n);
}
   
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

var (
	read  = bufio.NewReader(os.Stdin)
	write = bufio.NewWriter(os.Stdout)
)

func min(a, b int) int {
	if a <= b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a >= b {
		return a
	}
	return b
}

func yesno(result bool) {
	if result {
		fmt.Fprintln(write, "Yes")
	} else {
		fmt.Fprintln(write, "No")
	}
}

func printansStr(result bool, a, b string) {
	if result {
		fmt.Fprintln(write, a)
	} else {
		fmt.Fprintln(write, b)
	}
}

func printansInt(result bool, a, b int) {
	if result {
		fmt.Fprintln(write, a)
	} else {
		fmt.Fprintln(write, b)
	}
}

func main() {
	defer write.Flush()

	var s, t string
	fmt.Fscan(read, &s, &t)

	cnt := 0
	for i := 0; i < 3; i++ {
		if s[i] == t[i] {
			cnt++
		}
	}
	fmt.Fprintln(write, cnt)

}
//  [go]
package main

import "fmt"

func main() {
	var s, t string
	fmt.Scan(&s, &t)

	cnt := 0
	for i := 0; i < 3; i++ {
		if s[i:i+1] == t[i:i+1] {
			cnt++
		}
	}
	fmt.Println(cnt)
}
//  [go]
package main

import "fmt"

func main() {
	var s, t string
	fmt.Scan(&s, &t)
	cnt := 0
	for i := 0; i < len(s); i++ {
		if s[i] == t[i] {
			cnt++
		}
	}
	fmt.Println(cnt)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

func main() {
	S := getStdin()
	T := getStdin()

	ans := 0
	for i:=0 ; i<len(S) ; i++ {
		if S[i] == T[i] {
			ans++
		}
	}

	fmt.Printf("%d\n", ans)
}

var sc = bufio.NewReaderSize(os.Stdin, 1024*1024*10)

func getStdin() string {
	return readLine()
}
func getStdinInt() int {
	str := getStdin()
	rtn, _ := strconv.Atoi(str)
	return rtn
}
func getStdinInt2() (int, int) {
	list := getStdinIntArr()
	return list[0], list[1]
}
func getStdinInt3() (int, int, int) {
	list := getStdinIntArr()
	return list[0], list[1], list[2]
}
func getStdinInt64() int64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return rtn
}
func getStdinIntU64() uint64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return uint64(rtn)
}
func getStdinInt64_2() (int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1]
}
func getStdinInt64_3() (int64, int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1], list[2]
}
func getStdinIntArr() []int {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.Atoi(val)
	}
	return rtn
}
func getStdinIntArr64() []int64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int64, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.ParseInt(val, 10, 64)
	}
	return rtn
}
func getStdinIntArrU64() []uint64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]uint64, len(list))
	for idx, val := range list {
		r, _ := strconv.ParseInt(val, 10, 64)
		rtn[idx] = uint64(r)
	}
	return rtn
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}
func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}
func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}
func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}
func abs64(n int64) int64 {
	if n < 0 {
		return -n
	}
	return n
}
func readLine() string {
	buf := make([]byte, 0, 0)
	for {
		l, p, _ := sc.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}
//  [go]
package main

import "fmt"

func main() {
	var s, t string
	fmt.Scan(&s, &t)
	cnt := 0
	for i := 0; i < len(s)-1; i++ {
		if s[i] == t[i] {
			cnt++
		}
	}
	fmt.Println(cnt)
}
//  [ruby]
# 入力は以下の形式で標準入力から与えられる。
# S
# T
a_s = gets.chomp.split("")
a_t = gets.chomp.split("")

# ある 3 日間の天気予報が、長さ 3 の文字列 S として与えられます。
# S の i (1 ≤ i ≤ 3) 文字目が
# S のとき、i日目の天気予報が晴れだったことを、
# C のときは曇りだったことを、R のときは雨だったことを意味します。

# また 3 日間の実際の天気が、長さ 3 の文字列 T として与えられます。
# T の i (1 ≤ i ≤ 3)文字目が
# S のとき、i日目の実際の天気が晴れだったことを、
# C のときは曇りだったことを、
# R のときは雨だったことを意味します。

# p a_s
# p a_t
ans = 0
3.times do |idx|
  ans += 1 if a_s[idx] == a_t[idx]
end

# 3日間で天気予報が的中した日が何日あるかを出力してください。
p ans
//  [ruby]
f =->{[1,2,3].zip(gets.chars).map{|a| a*""}}
p (f[]&f[]).count
//  [ruby]
forecast = gets.chomp.split("")
result = gets.chomp.split("")

hits = forecast.zip(result).count do |f, r|
  f == r
end

p hits
//  [ruby]
n=gets.to_i
p (n-1)*n/2
//  [ruby]
a=gets.chars.each
b=gets.chars.each
ans=0
3.times{a.next==b.next ? ans+=1}
p ans
//  [ruby]
s = gets.chomp.split("")-
t = gets.chomp.split("")-
ans = 0
3.times do |i|
    ans += 1 if s[i] == t[i]
end
puts ans
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

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

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
    	e:chars,
        a:chars
    }
    let mut cnt = 0;
    if e[0]==a[0] { cnt += 1 }
    if e[1]==a[1] { cnt += 1 }
    if e[2]==a[2] { cnt += 1 }
       
    println!("{}", cnt);
}
//  [rust]
fn main() {
    let s: Vec<char> = {
        let s = read::<String>();
        s.chars().into_iter().collect()
    };
    let t: Vec<char> = {
        let t = read::<String>();
        t.chars().into_iter().collect()
    };

    let mut ret = 0;
    for i in 0..3 {
        if s[i] == t[i] {
            ret += 1;
        }
    }

    println!("{}", ret);
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().parse().ok().unwrap()
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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 s: Vec<char> = read::<String>().chars().collect();
    let t: Vec<char> = read::<String>().chars().collect();
    let mut ans: u32 = 0;

    for i in 0..s.len() {
        if s[i] == t[i] {
            ans += 1;
        }
    }
    println!("{}", ans);
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::Chars;

#[fastout]
fn main() {
    input! {
        S: Chars,
        T: Chars,
    }
    let mut cnt = 0;
    for i in 0..S.len() {
        if S[i] == T[i] {cnt += 1;}
    }
    println!("{}", cnt)
}
//  [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!{
        s: String,
        t: String,
    }
    println!("{}", s.chars().zip(t.chars()).filter(|(a, b)| a == b).count());
}
//  [rust]
use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

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

fn main(){
    let s = read_as_string().chars().collect::<Vec<char>>();
    let t = read_as_string().chars().collect::<Vec<char>>();

    println!("{}", s.into_iter().zip(t.into_iter()).filter(|(x, y)| *x == *y).count());

}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
 
let fc=readLine()!
let re=readLine()!
var result=0

for num in 0...2{
  let a=fc.index(fc.startIndex,offsetBy:num)
  let b=re.index(re.startIndex,offsetBy:num)
 
  if fc[a]==re[b] {
    result+=1
  }
}
print(result)
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func main() {
    let s = Array(readLine()!)
    let t = Array(readLine()!)
    
    var ans = 0
    for i in 0..<3 {
        if s[i] == t[i] {
            ans += 1
        }
    }
    
    print(ans)
}

main()
//  [swift]
var S = readLine()!
var T = readLine()!
var suuji = 0

for num in 0...2{
  let Sa = S.index(S.startIndex, offsetBy: num)
  let Ta = T.index(T.startIndex, offsetBy: num)
  if S [Sa]==T [Ta] {
    suuji += 1
  }
}
print(suuji)
//  [swift]
let s=Array(readLine()!)
let t=Array(readLine()!)
var count=0
for i in 0...2{
  if s[i]==t[i]{
    count+=1
  }
}
//  [swift]
let s = Array(readLine()!.characters)
let t = Array(readLine()!.characters)
 
var i = 0
var o = 0
for i in 0..<3 {
	if s[i] == t[i] {
      o ++
    }
}
 
print( o )
//  [swift]
let input_line = readLine() // 標準入力から１行目を取得
print(input_line)
//  [typescript]
import * as fs from "fs"

function solve() {
    const [S, T] = (require('fs').readFileSync("/dev/stdin", "utf8") as string).split("\n");
    let cnt = 0
    for (let i = 0; i < 3; i++) {
      if (S[i] === T[i]) {
        cnt += 1;
      }
    }
    console.log(cnt);
}

solve();
//  [typescript]
import * as fs from 'fs';

//in
//
//out
//
const main = (inp: string) => {
    const [s, t]: string[] = inp.split('\n').map(String);
    let ans: number = 0;
    for (let i: number = 0; i < 3; i++) {
        if (s[i] === t[i]) {
            ans++;
        }
    }
    console.log(ans);
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
((input: string): void => {
    const [s, t] = input.split("\n").map(v => v.split(""))
    console.log(s.filter((v, i) => v == t[i]).length)
})(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
a,b,c = map(int,input().split())

if a+b+c >= 22:
    print('bust')
else:
    print('win')
//  [python]
A, B, X = map(int, input().split())
ans = 'bust' if A+B+X >= 22 else 'win'
print(ans)
//  [python]
a,b,c = map(int,input().split())
s = a+b+c

if s > 21:
    print("bust")
else:
    print("win")
//  [python]
import sys
stdin=sys.stdin

ip=lambda: int(sp())

lp=lambda:list(map(int,stdin.readline().split()))
sp=lambda:stdin.readline().rstrip()

a,b,c=lp()
if a+b+c>=22:
  print('burst')
  
else:
  print('win')
//  [python]
a,b,c=map(int,input()split())
sum=a+b+c

if sum >=22:
  print("bust")
else:
  print("win")
//  [python]
from sys import stdin, stdout

def print(x):
    stdout.write(str(x))

def solve():
    A = [int(x) for x in stdin.readline().split()]
    sum = 0
    for a in A:
        sum += a
    if sum <= 22 :
        print("win")
    else:
        print("bust")

def main():
    solve()


if __name__ == "__main__":
    main()
//  [java]
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.StringTokenizer; 
  
class Main 
{ 
    public static void main(String[] args) throws IOException 
    { 
  
        BufferedReader br = new BufferedReader( 
                              new InputStreamReader(System.in)); 
  
        StringTokenizer st = new StringTokenizer(br.readLine()); 
        int a = Integer.parseInt(st.nextToken()); 
        int b = Integer.parseInt(st.nextToken()); 
        int c = Integer.parseInt(st.nextToken()); 
        if (a+b+c>=22) System.out.println("bust");
        else System.out.println("win"); 
    } 
}
//  [java]
import java.util.Scanner;

public class Main{

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a1,a2,a3;
    a1 = sc.nextInt();
    a2 = sc.nextInt();
    a3 = sc.nextInt();
    if(a1+a2+a3 > 21) {
      System.out.println("bust");
    }else {
      System.err.println("win");
    }
    sc.close();
  }

}
//  [java]
import java.util.*;
class Main{
  public static void main(String[] s){
    Scanner s = new Scanner(System.in);
    int a =sc.nextInt()+sc.nextInt()+sc.nextInt()-21;
    if(a>0){System.out.println("bust");}
    else{System.out.println("win");
        }
  }
}
//  [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();
        int c = sc.nextInt();
        if(a >= 1 && a <= 13 && b >= 1 && b <= 13 && c >= 1 && c <= 13){
     		 if(a + b + c <= 21){
        		System.out.println("Win");
     	   }else if(a + b + c >= 22){
        		System.out.println("bust");
        	}
        }
    }
}
//  [cpp]
#include <stdio.h>

int main(void) {
    int A1,A2,A3;
    
    scanf("%d %d %d",&A1,&A2,&A3);
    
    if (A1+A2+A3>=22) {
        printf("bust\n");
    } else {
        printf("win\n");
    }
    return 0;
}
//  [cpp]
#include <stdio.h>
int main(void){
    int A1,A2,A3,all;
    scanf("%d",&A1);
    scanf("%d",&A2);
    scanf("%d",&A3);
    all=A1+A2+A3;
    if(all>21){
        printf("bust\n");
    }else{
        printf("win\n");
    }
}
//  [cpp]
#include<stdio.h>
int main()
{
	double a,b,c;
	while(~scanf("%lf %lf %lf",&a,&b,&c))
	{
	if(a+b+c-22>=0)
	printf("bust\n");
	else
	printf("win\n");
	 } 
	
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main(void){
    int total = 0;
    vector<int> a(3);
    string ans;
    for(int i = 0; i < 3; i++) cin >> a[i];
    for(int i = 0; i < 3; i++) total += a[i];
    if(total == 21) ans = "win";
    else ans = "bust";
    cout << ans << endl;
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

#ifdef LOCAL
#define DEBUG(...) debug(#__VA_ARGS__, __VA_ARGS__);
#else
#define DEBUG(...) 6;
#endif

template<typename T, typename S> ostream& operator << (ostream &os, const pair<T, S> &p) {return os << "(" << p.first << ", " << p.second << ")";}
template<typename C, typename T = decay<decltype(*begin(declval<C>()))>, typename enable_if<!is_same<C, string>::value>::type* = nullptr>
ostream& operator << (ostream &os, const C &c) {bool f = true; os << "["; for (const auto &x : c) {if (!f) os << ", "; f = false; os << x;} return os << "]";}
template<typename T> void debug(string s, T x) {cerr << s << " = " << x << "\n";}
template<typename T, typename... Args> void debug(string s, T x, Args... args) {cerr << s.substr(0, s.find(',')) << " = " << x << " | "; debug(s.substr(s.find(',') + 2), args...);}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int a1, a2, a3;
    cin >> a1 >> a2 >> a3;
    cout << (a1 + a2 + a3 == 22 ? "bust" : "win") << "\n";

    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
    int a,b,c;
    cin >> a >> b >> c;
    cout << a+b+c << endl;
    if(a+b+c >= 22){
        cout << "bust" << endl;
    }else {
        cout << "win" << endl;
    }
    return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int main(){
	int a, b, c;
	scanf("%d%d%d", &a, &b, &c);
	puts(a+b+c>21?"bust":"win");
}
//  [c]
#include<stdio.h>
 
int main(void){
  int an=0;
  int sum=0;
  for(int i=0;i<3;i++){
    scanf("%d",&an);
    sum+=an;
  }
  if(sum>=22)
    printf("bust");
  else
    printf("win");
  return 0;
}
//  [c]
#include<stdio.h>

int main(){
  
  int n[3];
  int sum;
  sum = 0;
  
  for(int i = 0;i<3;i++)
  {
    scanf("%d",&n[i]);
    sum = sum + n[i];
  }
  
  if(sum >= 22){
    printf("%s\n","bust");
  }else{
    printf("%s\n","win");
  }
  return 0;
}
//  [c]
#include <stdio.h>

int main(){
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	if (a+b+c>= 22){
		printf("bust\n");
		printf("%d + %d + %d = %d, so print bust", a, b, c, a+b+c);
	}
	else {
		printf("win\n");
		printf("%d + %d + %d = %d, so print win", a, b, c, a+b+c);
	}
	return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>
int main(void){
  char S[200];
  scanf("%s",S);
  int leng;
  leng = strlen(S);
  int i,j;
  j=0;
  for(i=0;i<leng/2;i++){
    if(S[i]==S[leng-1-i])
      j++;
  }
  printf("%d",i-j);
  return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>
int main(void){
  char S[200];
  scanf("%s",S);
  int leng;
  leng = strlen(S);
  int i,j;
  j=0;
  for(i=0;i<leng/2 + 1;i++){
    if(S[i]==S[leng-i-1])
      j++;
  }
  printf("%d",j);
  return 0;
}
//  [javascript]
function main (input) {
  const a = input.split(' ')
  const sum = a.reduce((a, x) => a += parseInt(x, 10), 0)
  if (sum < 22) console.log('win')
  else console.log('bust')
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input) {
	const A = input.split("\n");
	
	const B = parseInt(A[0].split(" ")[0]) + parseInt(A[0].split(" ")[1]) + parseInt(A[0].split(" ")[2]);
	
	if (B >= 22) {
		console.log("bust");
	} else {
		console.log("win");
	}
}
 
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    var args = input.trim().split(' ').map(function(val) {
        return Number(val);
    });
    var sum = args[0] + args[1] + args[2];
    if(sum >= 22) {
        console.log('bust');
    } else {
        console.log('win');
    }
    
}
 
/*  var input = `13 7 2`;
Main(input);
 */ 
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
    input = input.trim().split("\n");
    var a = parseInt(input[0], 10);
    var b = parseInt(input[1], 10);
    var c = parseInt(input[2], 10);
    if (a+b+c >= 22) {
        console.log("bust");
    } else {
        console.log("win");
    }
  }
   
  main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main (input) {
  const a = input.split(' ')
  const sum = a.reduce((a, x) => a += parseInt(x, 10), 0)
  if (sum < 22) console.log('win')
  else console.log('bust')
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))ß
//  [javascript]
function main(arg) {
	arg = arg.trim().split(' ');
  	arg = arg.map(str => parseInt(str, 10));
	var bj = 21, result;
	result = arg[0] + arg[1] + arg[2];
console.log(result)
  if (result <= bj) {
  	console.log('win');
  } else {
  	console.log('bust');
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import "fmt"

func main() {
	var s int
	for i := 0; i < 3; i++ {
		var a int
		fmt.Scan(&a)
		s += a
	}
	if s >= 22 {
		fmt.Println("bust")
	} else {
		fmt.Println("win")
	}

}
//  [go]
package main

import "fmt"

func main(){
  var a, b, c int;
  fmt.Scan(&a, &b, &c);
  
  if a + b + c >= 22 {
    fmt.Println("bust");
  }else{
    fmt.Println("win");
  }
}
//  [go]
package main

import "fmt"

func main() {
	var a1, a2, a3 int
	fmt.Scan(&a1, &a2, &a3)
	
	if a1 + a2 + a3 > 21 {
		fmt.Println("bust")
	} else {
		fmt.Println("win")
		
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

const (
	BUFSIZE   = 10000000
	MOD       = 1000000007
	INF_INT   = math.MaxInt32
	INF_INT64 = math.MaxInt64
)

var rdr *bufio.Reader

func main() {
	rdr = bufio.NewReaderSize(os.Stdin, BUFSIZE)
	solve()
}

func solve() {
	A := readIntSlice(3)
	total := 0
	for _, v := range A {
		total += v
	}
	fmt.Println(total)
}

func readline() string {
	buf := make([]byte, 0, 16)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			fmt.Println(e.Error())
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func readIntSlice(size int) []int {
	slice := make([]int, size)
	lines := strings.Split(readline(), " ")
	for i, v := range lines {
		slice[i] = s2i(v)
	}
	return slice
}

func readInt64Slice(size int) []int64 {
	slice := make([]int64, size)
	lines := strings.Split(readline(), " ")
	for i, v := range lines {
		slice[i] = s2i64(v)
	}
	return slice
}

func readint() int {
	return s2i(readline())
}

func readint64() int64 {
	return s2i64(readline())
}

// For int64
func b2i64(b bool) int64 {
	if b {
		return 1
	}
	return 0
}

func abs64(v int64) int64 {
	if v < 0 {
		return -v
	}
	return v
}

func min64(values ...int64) int64 {
	ret := int64(INF_INT64)
	for _, v := range values {
		if ret > v {
			ret = v
		}
	}
	return ret
}

func max64(values ...int64) int64 {
	ret := -int64(INF_INT64)
	for _, v := range values {
		if ret < v {
			ret = v
		}
	}
	return ret
}

func s2i64(s string) int64 {
	v, ok := strconv.ParseInt(s, 10, 64)
	if ok != nil {
		panic("Faild : " + s + " can't convert to int64")
	}
	return v
}

// For int
func b2i(b bool) int {
	if b {
		return 1
	}
	return 0
}

func abs(v int) int {
	if v < 0 {
		return -v
	}
	return v
}

func min(values ...int) int {
	ret := INF_INT
	for _, v := range values {
		if ret > v {
			ret = v
		}
	}
	return ret
}

func max(values ...int) int {
	ret := -INF_INT
	for _, v := range values {
		if ret < v {
			ret = v
		}
	}
	return ret
}

func s2i(s string) int {
	v, ok := strconv.Atoi(s)
	if ok != nil {
		panic("Faild : " + s + " can't convert to int")
	}
	return v
}

func lcm(v1, v2 int) int {
	if v1 > v2 {
		v1, v2 = v2, v1
	}
	for v1 != 0 {
		v1, v2 = v2%v1, v1
	}
	return v2
}

func gcd(v1, v2 int) int {
	return v1 * v2 / lcm(v1, v2)
}

func bit(size int) [][]bool {
	bSize := int(math.Pow(2, float64(size)))
	b := make([][]bool, bSize)
	for i := 0; i < bSize; i++ {
		b[i] = make([]bool, size)
		for j := 0; j < size; j++ {
			if i>>j&1 == 1 {
				b[i][j] = true
			} else {
				b[i][j] = false
			}
		}
	}
	return b
}

/* ------------------------------------------------ */
/* Data stracture                                   */
/* ------------------------------------------------ */
type IntHeap []int

func (h *IntHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
//  [ruby]
a,b,c= gets.split.map(&:to_i)
  if a + b + c >= 22
    puts "bust"
  else
    puts "win"
  end
//  [ruby]
numbers = gets.split.map(&:to_i)
 
if numbers.inject(:+) >= 22
  puts 'bust'
else
  puts 'win'
end
//  [ruby]
a = gets.split.map(&:to_i)
puts a.inject {|sum, n| sum + n } > 21 ? "bust" : "win"
//  [ruby]
p gets.split.map(&:to_i).sum>21 ? :bust : :win
//  [ruby]
p (gets.split.map(&:to_i).inject(:+) >= 22 ? "bust" : "win")
//  [ruby]
A = gets.split.map(&:to_i).sum
puts A > 21 ? "bust" : "win"
//  [rust]
use std::io::*;
use std::str::FromStr;

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: Vec<u16> = (0..3).map(|_| read()).collect();

    let sum:u16 = a.iter().sum();

    if sum >= 22 {
        println!("bust");
    }else{
        println!("win")
    }
    
}
//  [rust]
use std::io::*;
use std::str::FromStr;
 
/* 
The read function reads a string according to each one. 
*/
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")
}

//main function
fn main() {
    let mut sum: i8 = 0;
    for _i in 0..3{
	let a: i8 = read();
	sum += a;
    }
    if sum > 21{
	println!("bust");
    }else{
	println!("win");
    }
}
//  [rust]
//入力マクロここから
//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules ! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }
macro_rules ! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( "Parse error" ) } ; }
macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }
//入力マクロここまで

fn main() {
    input! {
        xs: [u64;3],
    }

    if xs.iter().sum::<u64>() >= 22 {
        println!("bust");
    } else {
        println!("win");
    }
}
//  [rust]
use proconio::*;

#[fastout]
fn main() {
    input! {
        a: i32,
        b: i32,
        c: i32
    }
    println!("{}", if a + b + c >= 22 { "bust" } else { "win" });
}
//  [rust]
fn read<T: std::str::FromStr>() -> T {
  let mut s = String::new();
  std::io::stdin().read_line(&mut s).ok();
  s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
  read::<String>().split_whitespace()
    .map(|e| e.parse().ok().unwrap()).collect()
}

fn read_vec2<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
  (0..n).map(|_| read_vec()).collect()
}

fn main() {
  let (a1, a2, a3) = {
    let tmp: Vec<i8> = read_vec();
    (tmp[0], tmp[1], tmp[2])
  };

  let ans: &str = {
    if (a1+a2+a3) >= 22 {
      "burst"
    } else {
      "win"
    }
  };

  println!("{}", ans);
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
    
let abc = readInts()
let a = abc[0]
let b = abc[1]
let c = abc[2]
if (a+b+c)<=21{
  print("win")
}else{
  print("bust")
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let b = readInts()
let a1 = b[0]
let a2 = b[1]
let a3 = b[2]
let num = a1 + a2 + a3
if num >= 22 {
  print("bust")
} else { 
  print("win")
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
 
let num=readInts()
let ans=num[0]+num[1]+num[2]

if(ans<22){print("win")}else{print("bust")}