#include <bits/stdc++.h>

using namespace std;
typedef long long lli;
typedef unsigned long long int uli;
typedef long double Lf;

#define fastIO  std::ios::sync_with_stdio(false);cin.tie(NULL)
#define mod 1000000007
#define BIGL = 999999999999999999
#define BIGI = 99999999
#define N 25
#define NN 25
#define vi vector<int>
#define vl vector<long>
#define vll vector<long long>
#define vc vector<char>
#define ii <int, int>
#define ll <long, long>
#define lll <long long, long long>
#define loop(i,s,n) for(int i=s;i<n;i++)
#define loopr(i,n,s) for(int i=n-1;i>=s;i--)
#define pb push_back
#define o2(a,b) cout<<a<<" "<<b<<endl
#define o3(a,b,c) cout<<a<<" "<<b<<" "<<c<<endl
#define o4(a,b,c,d) cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl
#define cl cout<<endl
#define r0 return 0
#define x first
#define y second


inline lli modadd(lli n,lli m){
    return ((n+m)%mod+mod)%mod;
}

inline lli modsub(lli n,lli m){
    return ((n-m+mod)%mod+mod)%mod;
}

inline lli modpro(lli n,lli m){
    return ((n*m)%mod+mod)%mod;
}



inline uli powe(lli x,lli y){
    uli res = 1;
    while (y > 0) {
        if (y & 1)
            res = res * x;
        y = y >> 1;
        x = x * x;
    }
    return res;
}



inline lli powmod(lli x,lli y){
    lli res = 1;
    while (y > 0) {
        if (y & 1)
            res = modpro(res , x);
        y = y >> 1;
        x = modpro(x , x);
    }
    return res;
}

inline lli modadd3(lli x, lli y, lli z){
    return modadd(modadd(x,y),z);
}

inline lli modadd4(lli x, lli y, lli z, lli w){
    return modadd(modadd(x,y),modadd(z,w));
}

template <typename T>
inline T max3(T x, T y, T z){
    return max(max(x,y),z);
}

template <typename T>
inline T max4(T x, T y, T z, T w){
    return max(max3(x,y,w),z);
}

template <typename T>
inline T min3(T x, T y, T z){
    return min(min(x,y),z);
}

template <typename T>
inline T min4(T x, T y, T z, T w){
    return min(min3(x,y,w),z);
}


template <typename T>
void printArr(T *arr, int n){
    for(int i=0;i<n;i++){

        cout<<arr[i]<<" ";
    }cout<<endl;
}





//
//
//template <class T, class U>
//bool comparep(const pair<T, U>&i, const pair<T, U>&j)
//{
//    return i.first > j.first;
//}
//
//template <class T, class U>
//bool compair2(const pair<T, U>&i, const pair<T, U>&j)
//{
//    return ((i.second < j.second)||((i.second == j.second)&&i.first < j.first));
//}
//
//

//template <typename T>
//T gcd(T a, T b)
//{
//    if (a == 0)
//        return b;
//    if(b==0)
//        return a;
//    T t;
//    while((a>0)&&(b>0)){
//     t = a;
//     a=b%a;
//     b=t;
// }
//
// return max(a,b);
//}
//


//template <typename T>
//T maxof(T n_args, ...)
//{
//    va_list ap;
//    va_start(ap, n_args);
//    T big = va_arg(ap, T);
//    for(int i = 2; i <= n_args; i++) {
//        T a = va_arg(ap, T);
//        if(a > big) big = a;
//    }
//    va_end(ap);
//    return big;
//}
//
//
//
//
//template <typename T>
//T gcdarr(T a[], int n){
//    T gc = gcd<T>(a[0],a[1]);
//    loop(i,2,n) {
//        gc = gcd<T>(gc,a[i]);
//    }
//    return gc;
//}
//
//
//template <typename T>
//T maxarr(T a[], int n){
//    T big = a[0];
//    loop(i,1,n) {
//        big = max(big, a[i]);
//    }
//    return big;
//}
//
//
//
//template <typename T>
//T minarr(T a[], int n){
//    T small = a[0];
//    loop(i,1,n) {
//        small = min(small, a[i]);
//    }
//    return small;
//}
//
//uli choose(uli n, uli k){
//uli res = 1;
//
//    // Since C(n, k) = C(n, n-k)
//    if ( k > n - k )
//        k = n - k;
//
//    // Calculate value of
//    // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
//    for (uli i = 0; i < k; ++i)
//    {
//        res *= (n - i);
//        res /= (i + 1);
//    }
//
//    return res;
//}
//

//vector<int> v[N];
////bool visited[N];
////queue<int> q;
////int color[N];
//class Graph{
//
// public:
//    int V;
//
//
//
//    Graph(int V)
//{
//    this->V = V;
//
//}
//
//    void addEdge(int a, int b)
//{
//    v[a].insert(b);
//    v[b].insert(a);
//}
//
////void dfs(int x, int c){
////        if(visited[x]==0)
////    {visited[x]=1;
////    color[x]=c;
////    //cout<<x<<endl;
////    for(int u:v[x])
////    {
////        dfs(u,c);
////    }}
////     }
//
//
////void bfs(int n,int x){
////    visited[x]=1;
////    q.push(x);
////    while(!q.empty())
////    {
////        int s = q.front();
////        q.pop();
////
////        for(int u : v[s]){
////            if(visited[u]==1) continue;
////            visited[u]=1;
////            //cout<<u<<endl;
////            q.push(u);}}}
//
////int connectedcomponents(int n){
////    int ans=0;
////    loop(i,1,n+1){
////        if(!visited[i]){
////            ans++;
////            dfs(i);
////        }
////
////    }
////    return ans;
////}
//
//};


//
//
//vector<int> parent, rank_;
//
//void makeSet(int x){
//	parent[x]=x;
//	rank_[x]=0;
//}
//
//int findSet(int x){
//	if(x!=parent[x])
//		parent[x]=findSet(parent[x]);
//
//	return parent[x];
//}
//
//void unionSets(int x, int y){
//	int px = findSet(x);
//	int py = findSet(y);
//
//	if(rank_[px]<rank_[py]){
//		parent[px]=py;
//		mm[py]=max(mm[px],mm[py]);
//	}
//	else if(rank_[py]<rank_[px]){
//		parent[py]=px;
//		mm[px]=max(mm[px],mm[py]);
//	}
//	else{
//		parent[py]=px;
//		mm[px]=max(mm[px],mm[py]);
//		rank_[px]++;
//	}
//
//}
//










//
//template <typename T>
//T findpowerfactorial(T n,T p)
//{
//    T x = 0;
//    while (n)
//    {
//        n /= p;
//        x += n;
//    }
//    return x;
//}
//
//template <typename T>
//int getibit(T n, int i){
//    //cout<<(n&(1LL<<i))<<endl;
//    return (n&(1LL<<i))?1:0;
//}
//
//template <typename T>
//int findbits(T n, T p){
//    int x=0;
//    while(n>0){
//        n/=p;
//        x++;
//    }
//    return x;
//}
//
//
//void primeFactors(int n)
//{
//    while (n % 2 == 0)
//    {
//        cout << 2 << " ";
//        n = n/2;
//    }
//
//
//    for (int i = 3; i <= sqrt(n); i = i + 2)
//    {
//        while (n % i == 0)
//        {
//            cout << i << " ";
//            n = n/i;
//        }
//    }
//    if (n > 2)
//        cout << n << " ";
//}
//
//
//
//



// bool c2(pair<lli, lli> p, pair<lli, lli> q){
// 	return p.x<q.x||((p.x==q.x)&&(p.y>q.y));
// }


//vll v[4];
//
//lli gcd(lli a, lli b){
//    int ta=max(a,b),tb=min(a,b);
//int tr,td;
//    while(ta>0&&tb>0){
//
//        tr = ta%tb;
//        td = ta/tb;
//        o4(ta,tb,tr,td);cout<<"x";
//        v[0].pb(ta);v[1].pb(td);v[2].pb(tb);v[3].pb(tr);
//        ta=tb;
//        tb=tr;
//
//    }
//    return max(ta,tb);
//}
//
//
//lli wb,wd;
//void fa(int w,int x){
//    lli a,b,c,d;
//    int n=v[0].size();
//    lli temp;
//    cout<<n<<"%";
//    if(n==1){
//        a=1;b=w; c=w/x-1;d=x;
//    }
//    else {b=v[0][n-2];a=1;c=-1*v[1][n-2];d=v[2][n-2];
//    loopr(i,v[0].size()-2,0){
//        o4(a,b,c,d);
//        d=b;
//        temp = c;
//        c = a-c*v[1][i];
//        a=temp;
//        b=v[0][i];
//    }}
//    cout<<"hi";
//    o4(a,b,c,d);
//    wb=b,wd=d;
//
//}



//lli gcd(lli a, lli b)
//{
//    if (a == 0)
//        return b;
//    if(b==0)
//        return a;
//    lli t;
//    while((a>0)&&(b>0)){
//     t = a;
//     tr = b%a;
//
//     a=b%a;
//     b=t;
// }
//
// return max(a,b);
//}

//lli power(lli x, lli y, lli p)
//{
//    lli res = 1;      // Initialize result
//
//    x = x % p;  // Update x if it is more than or
//                // equal to p
//
//    while (y > 0)
//    {
//        // If y is odd, multiply x with result
//        if (y & 1)
//            res = (res*x) % p;
//
//        // y must be even now
//        y = y>>1; // y = y/2
//        x = (x*x) % p;
//    }
//    return res;
//}
//
//// Returns n^(-1) mod p
//int modInverse(int n, lli p)
//{
//    return power(n, p-2, p);
//}
//
//// Returns nCr % p using Fermat's little
//// theorem.
//lli fac[N];
//void facinit(int n){
//    fac[0]=1;
//    for (int i=1 ; i<=n; i++)
//        fac[i] = fac[i-1]*i%mod;
//}
//int nCrModPFermat(int n, int r, lli p)
//{
//   // Base case
//   if (r==0)
//      return 1;
//
//    // Fill factorial array so that we
//    // can find all factorial of r, n
//    // and n-r
//    //o3(n,r,p);
//    //o3(fac[n],modInverse(fac[r], p),modInverse(fac[n-r], p));
//    return (fac[n]* modInverse(fac[r], p) % p *
//            modInverse(fac[n-r], p) % p) % p;
//}


int main(){
    //fastIO;
    int erer=1;
    //cin>>erer;
    loop(erer2,1,erer+1){

        int a1,a2,a3;
        cin>>a1>>a2>>a3;
        if(a1+a2+a3>=22) cout<<"bust"<<endl;
        else cout<<"win"<<endl;


    }
    return 0;
}







Measured memory_bytes: 256