import java.util.*; 
import java.io.*;
import java.math.*;
import java.util.stream.*;
import java.util.function.*;

class Main implements Runnable {

    public void solve() {    
        String s = in.next() , t = in.next();
        Set<Character> set = new HashSet<>();
        set.add(s.charAt(0));
        set.add(t.charAt(0));
        if(!set.contains('b')) out.print("beachball");
        else if(!set.contains('w')) out.print("watermelon");
        else out.print("shrinebell");
    }

    // ===============================================================================================================

    

    // ===============================================================================================================

    public PrintWriter out = new PrintWriter(System.out);
    public In in = new In() ;
    public static final int  inf = (1  << 30);
    public static final long lnf = (1L << 60);
    public static final String yes = "Yes" , no  = "No" ;
    public static final int mod7 = 1000000007 , mod9 = 998244353;
    public static final int [] dy4 = {-1,0,1,0} , dx4 = {0,1,0,-1};
    public static final int [] dy8 = {-1,-1,-1,0,1,1,1,0} , dx8 = {-1,0,1,1,1,0,-1,-1};
    public record IntP(int fi , int se) { public String toString() { return fi + " "+ se ;} }
    public record LongP(long fi , long se) { public String toString() { return fi + " "+ se ;} }
    public record StringP(String fi , String se) { public String toString() { return fi + " "+ se ;} }
    public record Edge(int to , long weight) { public String toString() { return to + " "+ weight ;}}
    public record State(int now , long dist) { public String toString() { return now + " "+ dist ; }}
    public record Pair<T,S> (T fi , S se) { public String toString() { return "("+fi+","+se+")";}}

    // ===============================================================================================================

    public static void main(String ... args) { new Thread(null, new Main(), "", Runtime.getRuntime().maxMemory()).start(); }

    public void run() { solve(); out.flush(); }

    // ===============================================================================================================

    public static char shiftCharacter(char ch, int shift) {
        if (Character.isLetter(ch)) {
            char base = Character.isUpperCase(ch) ? 'A' : 'a';
            shift = shift % 26;
            return (char) (((ch - base + shift + 26) % 26) + base);
        }
        return ch;
    }

    public long toMultiple(long u , long m) { return m - (u % m); }

    public boolean isOut(int uY , int uX , int qH , int qW) { return (0 < uY || 0 < uX || qH >= uY || qW >= uX) ; }

    public void swap(int [] array, int n, int m) { int swap = array[n]; array[n] = array[m]; array[m] = swap; }

    public <T> T getKth(TreeSet<T> set , int kth) { int count = 0 ; for(T u : set) if(kth == ++count) return u ; return null ; }

    public <T extends Comparable<T>> int lowClosed(List<T> A , T key) { return upperbound(A, key); }

    public <T extends Comparable<T>> int lowOpen(List<T> A , T key) { return lowerbound(A, key); }

    public <T extends Comparable<T>> int highClosed(List<T> A , T key) { return A.size() - lowerbound(A, key); }

    public <T extends Comparable<T>> int highOpen(List<T> A , T key) { return A.size() - upperbound(A, key); }

    public <T extends Comparable<T>> int closedOpen(List<T> A, T a, T b) { return lowerbound(A, b) - lowerbound(A, a); }

    public <T extends Comparable<T>> int closedClosed(List<T> A, T a, T b) { return upperbound(A, b) - lowerbound(A, a); }

    public <T extends Comparable<T>> int openClosed(List<T> A, T a, T b) { return upperbound(A, b) - upperbound(A, a); }

    public <T extends Comparable<T>> int openOpen(List<T> A, T a, T b) { return lowerbound(A, b) - upperbound(A, a); }

    public <T extends Comparable<T>> int lowerbound(List<T> A, T key) {
        int left = 0 , right = A.size();
        while (left < right) {
            int mid = (left + right) / 2;
            if (A.get(mid).compareTo(key) < 0) left = mid + 1;
            else right = mid;
        }
        return right;
    }

    public <T extends Comparable<T>> int upperbound(List<T> A, T key) { 
        int left = 0 , right = A.size();
        while (left < right) {
            int mid = (left + right) / 2;
            if (A.get(mid).compareTo(key) <= 0) left = mid + 1;
            else right = mid;
        }
        return right;
    }

    public <T> Map<T,Integer> compress(List<T> u) {
        Set<T> order = new TreeSet<>(u); Map<T,Integer> res = new HashMap<>(); int rank = 0 ;
        for(T obj : order) res.put(obj , rank++);
        return res ;
    }

    public List<Long> subset(long u) {
        List<Long> res = new ArrayList<>();
        for (long sub = (u - 1) & u ; sub > 0 ; sub = (sub - 1) & u) res.add(sub);
        return res ;
    }

    public long [][] pascal(int n) {
        int MAX = n;
        long [][] com = new long[MAX][MAX];
        for(int i = 0; i < MAX; i ++ ) com[i][0] = 1;
        for(int i = 1; i < MAX; i ++ ) for(int j = 1; j <= i; j ++ ) com[i][j] = com[i-1][j-1] + com[i-1][j];
        return com ;
    }

    public boolean nextPermutation(int [] array) {
        if (array == null) return false;
        for (int change = array.length - 2; change >= 0; --change) {
            if (array[change] < array[change + 1]) {
                int min = change, max = array.length, halfDiff, mid;
                while ((halfDiff = max - min >> 1) != 0) {
                    if (array[change] < array[mid = min + halfDiff]) min = mid;
                    else max = mid;
                }
                swap(array, change, min);
                for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
                return true;
            }
        }
        return false;
    }

    public boolean prevPermutation(int [] array) {
        if (array == null) return false;
        for (int change = array.length - 2; change >= 0; --change) {
            if (array[change] > array[change + 1]) {
                int min = change, max = array.length, halfDiff, mid;
                while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
                else max = mid;
                swap(array, change, min);
                for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
                return true;
            }
        }
        return false;
    }

    public int [] bfs(int start , List<Integer>[] G) {
        int [] dist = new int[G.length];
        Arrays.fill(dist , inf);
        dist[start] = 0 ;
        Queue<Integer> Q = new ArrayDeque<>();
        Q.add(start);
        while(!Q.isEmpty()) {
            int now = Q.poll();
            for(int next : G[now]) {
                if(dist[next] < dist[now] + 1) continue;
                dist[next] = dist[now] + 1 ;
                Q.add(next);
            }
        }
        return dist;
    }

    public long [] Dijkstra(int start , List<Edge>[] G) {
        long [] cur = new long[G.length];
        Set<Integer> visited = new HashSet<>();
        long NULL = (long)1e18;
        Arrays.fill(cur,NULL);
        cur[start] = 0 ;
        Queue<State> Q = new PriorityQueue<>(Comparator.comparing(State::dist));
        Q.add(new State(start , 0));
        while(!Q.isEmpty()){
            State d = Q.poll();
            int now = d.now;
            if(visited.contains(now)) continue;
            visited.add(now);
            for(Edge v : G[now]){
                int next = v.to;
                long weights = v.weight;
                if(cur[now] + weights < cur[next]){
                    cur[next] = cur[now] + weights ;
                    Q.add(new State(next , cur[next]));
                }
            }
        }
        return cur ;
    }

    // ===============================================================================================================

    public Integer [] parseInt(int [] array) { return IntStream.of(array).boxed().toArray(Integer[]::new); }

    public Long [] parseLong(long [] array) { return LongStream.of(array).boxed().toArray(Long[]::new); }

    // ===============================================================================================================

    class MultiSet<T> {

        private TreeMap<T,Integer> set ;
        private int count ;
        
        MultiSet() { 
            this.set = new TreeMap<>(); 
            this.count = 0 ;
        }

        public void add(T x) { 
            set.put(x , set.getOrDefault(x , 0) + 1);
            count++;
        }

        public void add(T x , int cnt) {
            set.put(x , set.getOrDefault(x , 0) + cnt);
            count += cnt;
        }

        public void remove(T x) { 
            if(set.get(x) == 1) set.remove(x) ; 
            else set.put(x , set.get(x) - 1); 
            count--; 
        }

        public void remove(T x , int cnt) { 
            if(set.get(x) - cnt == 0) set.remove(x) ; 
            else set.put(x , set.get(x) - cnt); 
            count -= cnt; 
        }

        public void removeAll(T x) {
            if(set.containsKey(x)) {
                count -= set.get(x);
                set.remove(x);
            }
        }

        public T peekFirst() { return set.firstKey(); }

        public T peekLast() { return set.lastKey(); }

        public T pollFirst() { 
            count--;
            T first = set.firstKey();
            if(set.get(first) == 1) set.pollFirstEntry();
            else set.put(first , set.get(first) - 1);
            return first;
        }

        public T pollLast() {
            count--;
            T last = set.lastKey();
            if(set.get(last) == 1) set.pollLastEntry();
            else set.put(last , set.get(last) - 1);
            return last;
        }

        public boolean isEmpty() { return set.isEmpty(); }

        public int count(T x) { return set.get(x); }

        public int size() { return count; }

        public void clear() { set.clear(); this.count = 0 ; }

    }

    class Deque<E> {

        private Object [] buf;
        private int head;
        private int tail;
        private int N;

        public Deque() {
            this(300000);
        }

        public Deque(int max_size) {
            this(new Object[0], max_size);
        }

        public Deque(Object[] src_arr, int max_size) {
            N = Math.max(max_size, src_arr.length) + 1;
            buf = Arrays.copyOf(src_arr, N);
            head = 0;
            tail = src_arr.length;
        }

        public void add(E x) {
            addFirst(x);
        }

        public void addFirst(E x) {
            if (isFull()) extend();
            head = (head - 1 + N) % N;
            buf[head] = x;
        }

        public void addLast(E x) {
            if (isFull()) extend();
            buf[tail] = x;
            tail = (tail + 1) % N;
        }

        public E poll() {
            return pollFirst();
        }

        public E pollFirst() {
            if (isEmpty()) throw new IndexOutOfBoundsException("null");
            @SuppressWarnings("unchecked")
            E ret = (E)buf[head];
            buf[head] = null;
            head = (head + 1) % N;
            return ret;
        }

        public E pollLast() {
            if (isEmpty()) throw new IndexOutOfBoundsException("null");
            tail = (tail - 1 + N) % N;
            @SuppressWarnings("unchecked")
            E ret = (E)buf[tail];
            buf[tail] = null;
            return ret;
        }

        @SuppressWarnings("unchecked")
        public E peekFirst() {
            return (E)buf[head];
        }

        @SuppressWarnings("unchecked")
        public E peekLirst() {
            return (E)buf[tail];
        }

        @SuppressWarnings("unchecked")
        public E get(int key) {
            return (E)buf[index(key)];
        }

        public void set(int key , E value) {
            buf[index(key)] = value;
        }

        public boolean isFull() {
            return size() >= N - 1;
        }

        public boolean isEmpty() {
            return size() == 0;
        }

        private int index(int i) {
            int l = size();
            if (i < -l || i >= l) throw new IndexOutOfBoundsException("index out of range: " + i);
            if (i < 0) i += l;
            return (head + i) % N;
        }

        private void extend() {
            int ex = N - 1;
            buf = Arrays.copyOf(buf, buf.length + ex);
            N = buf.length;
            if (head > 0) head += ex;
        }

        public int size() {
            return (tail - head + N) % N;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("Deque(");
            for (int i = 0; i < size(); i++) {
                if (i > 0) sb.append(", ");
                sb.append(buf[(head + i) % N]);
            }
            sb.append(")");
            return sb.toString();
        }

    }

    class FenwickTree {

        private long N;
        private long [] data;

        public FenwickTree(int n) {
            N = n;
            data = new long[n+1];
        }

        public long sum(int i) {
            long s = 0;
            while (i > 0) {
                s += data[i];
                i -= i & (-i);
            }
            return s;
        }

        public long range(int i, int j) {
            return sum(j) - sum(i-1);
        }

        public void set(int i, long x) {
            add(i, x-range(i, i));
        }

        public void add(int i, long x) {
            while (i <= N) {
                data[i] += x;
                i += i & (-i);
            }
        }
        
    }

    class SegmentTree <T> {

        private int n ;
        private T init ;
        private T [] tree ;
        private int size ;
        private BinaryOperator<T> op ;

        @SuppressWarnings ("unchecked")
        SegmentTree(int size , T init , BinaryOperator<T> op) {
            this.size = size;
            this.init = init ;
            this.op = op ;
            n = 1 ;
            while(n <= size) n *= 2 ;
            this.tree = (T []) new Object[2 * n];
            for(int i = 0 ; i < 2 * n ; i ++ ) tree[i] = init ;
        }

        public void update(int index , T value) {
            index += n ;
            tree[index] = value ;
            while(index > 0) {
                index /= 2 ;
                tree[index] = op.apply(tree[2 * index] , tree[2 * index + 1]);
            }
        }

        public T query(int l , int r){
            l += n ; r += n ;
            T res = init ;
            while(l < r){
                if(l % 2 == 1){ res = op.apply(res , tree[l]) ; l ++ ; }
                l /= 2 ;
                if(r % 2 == 1){ res = op.apply(res , tree[r - 1]) ; r -- ; }
                r /= 2 ;
            }
            return res ;
        }

        @Override 
        public String toString() {
            StringBuilder sb = new StringBuilder();
            for(int i = n ; i < n + size ; i ++ ) sb.append(tree[i]+" ");
            return sb.toString() ;
        }

    }

    class UnionFind {

        private int [] rank , parents , size ;
        private int group_count ;

        UnionFind(int n) {
            this.rank = new int[n];
            this.parents = new int[n];
            this.size = new int[n];
            this.group_count = n ; 
            Arrays.fill(size , 1);
            for(int i = 0 ; i < n ; i ++ ) parents[i] = i ;
        }

        public int groupcount() { return this.group_count ; }

        public int membercount(int x) { return size[root(x)] ; }

        public boolean same(int x , int y) { return root(x) == root(y) ; }

        public int root(int x) {
            if(x == parents[x]) return x ;
            else parents[x] = root(parents[x]);
            return parents[x];
        }

        public void unite(int l , int r) {

            int left  = root(l);
            int right = root(r);
            int parent = -1 , child = -1 ;
            if(left == right) return ;
            parent = rank[left] > rank[right] ? left : right;
            child = rank[left] > rank[right] ? right : left ;
            --group_count;
            parents[child] = parent ;
            if(rank[parent] == rank[child]) rank[parent] ++ ;
            size[parent] += size[child] ; 
        }

        @SuppressWarnings("unchecked")
        public List<Integer> [] groupList() {
            List<Integer> [] ret = new ArrayList[group_count];
            int count = 0 ;
            for(int i = 0 ; i < group_count ; i ++) ret[i] = new ArrayList<>();
            Map<Integer,List<Integer>> mp = new HashMap<>();
            for(int i = 0 ; i < parents.length ; i ++ ) {
                int par = root(i);
                if(!mp.containsKey(par)) mp.put(par , new ArrayList<>());
                mp.get(par).add(i);
            }
            for(List<Integer> temp : mp.values()) ret[count++] = temp ;
            return ret ;
        }

    }

    class WaveletMatrix {

        private int [][] data;
        private int n, bit;

        WaveletMatrix(int [] d, int bit) {
            n = d.length;
            this.bit = bit;
            int[] dat = d.clone();
            data = new int[bit][n];
            int[] que = new int[n];
            for (int k = bit - 1; k >= 0; k--) {
                int que1 = 0, que2 = n;
                for (int i = 0; i < n; i++) {
                    if ((data[k][i] = (dat[i] >> k) & 1) == 1)
                        que[--que2] = dat[i];
                    else
                        que[que1++] = dat[i];
                }
                for (int i = 0; i < que1; i++)
                    dat[i] = que[i];
                for (int i = n - 1, j = que1; i >= que1; i--, j++)
                    dat[j] = que[i];
                for (int i = 1; i < n; i++)
                    data[k][i] += data[k][i - 1];
            }
        }

        WaveletMatrix(int [] dat) {
            this(dat, 31);
        }

        private int get(int bi, int id) {
            if (id == 0)
                return data[bi][0];
            return data[bi][id] - data[bi][id - 1];
        }

        public int access(int idx) {
            int ans = 0;
            for (int k = bit - 1; k >= 0; k--) {
                if (get(k, idx) == 1) {
                    ans |= 1 << k;
                    idx = zer(k, n) + one(k, idx);
                } else
                    idx -= data[k][idx];
            }
            return ans;
        }

        private int one(int bi, int l) {
            if (l == 0)
                return 0;
            return data[bi][l - 1];
        }

        private int zer(int bi, int l) {
            return l - one(bi, l);
        }

        private int sum(int bi, int l, int r) {
            return one(bi, r) - one(bi, l);
        }

        public int kth_smallest(int l, int r, int kth) {
            int ans = 0;
            for (int k = bit - 1; k >= 0; k--) {
                int s = r - l - sum(k, l, r);
                if (kth < s) {
                    l = zer(k, l);
                    r = l + s;
                } else {
                    kth -= s;
                    ans |= 1 << k;
                    int ran = r - l - s;
                    l = zer(k, n) + one(k, l);
                    r = l + ran;
                }
            }
            return ans;
        }

        public int kth_largest(int l, int r, int kth) {
            return kth_smallest(l, r, r - l - kth);
        }

        public int count_lower(int l, int r, int lower) {
            int ans = 0;
            for (int k = bit - 1; k >= 0; k--) {
             int s = r - l - sum(k, l, r);
                if (((lower >> k) & 1) == 1) {
                    ans += s;
                    int ran = r - l - s;
                    l = zer(k, n) + one(k, l);
                    r = l + ran;
                } else {
                    l = zer(k, l);
                    r = l + s;
                }
            }
            return ans;
        }

        public int count_upper(int l, int r, int upper) {
            return r - l - count_lower(l, r, upper + 1);
        }

        public int count(int l, int r, int x) {
            return count_lower(l, r, x + 1) - count_lower(l, r, x);
        }

        public int higher(int l, int r, int upper) {
            int cnt = count_lower(l, r, upper + 1);
            return kth_smallest(l, r, cnt);
        }

        public int lower(int l, int r, int lower) {
            int cnt = count_upper(l, r, lower - 1);
            return kth_largest(l, r, cnt);
        }

    }

    class mint {
        
        private long value;
        private final long MOD;

        public mint(long value, long MOD) {
            this.MOD = MOD;
            this.value = (value % MOD + MOD) % MOD;
        }

        public mint add(mint other) {
            return new mint((this.value + other.value) % MOD, MOD);
        }

        public mint subtract(mint other) {
            return new mint((this.value - other.value + MOD) % MOD, MOD);
        }

        public mint multiply(mint other) {
            return new mint((this.value * other.value) % MOD, MOD);
        }

        public mint inverse() {
            return new mint(pow(this.value, MOD - 2), MOD);
        }

        public mint divide(mint other) {
            return this.multiply(other.inverse());
        }

        private long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                if ((b & 1) != 0) {
                    res = (res * a) % MOD;
                }
                a = (a * a) % MOD;
                b >>= 1;
            }
            return res;
        }

        public long getVal() {
            return value;
        }

        @Override
        public String toString() {
            return String.valueOf(value);
        }
        
    }

    class Combination {

        private final mint[] factorial;
        private final mint[] inverseFactorial;
        private final long MOD;

        Combination(int maxN , long MOD) {
            this.MOD = MOD;
            this.factorial = new mint[maxN + 1];
            this.inverseFactorial = new mint[maxN + 1];
            init();
        }

        private void init() {
            factorial[0] = new mint(1, MOD);
            for (int i = 1 ; i < factorial.length ; i++ ) factorial[i] = factorial[i - 1].multiply(new mint(i, MOD));
            inverseFactorial[factorial.length - 1] = factorial[factorial.length - 1].inverse();
            for (int i = factorial.length - 2 ; i >= 0 ; i -- ) inverseFactorial[i] = inverseFactorial[i + 1].multiply(new mint(i + 1, MOD));
        }

        public mint fact(int x) {
            return factorial[x];
        }

        //nCk
        public mint comb(int n, int k) {
            if (n < k) return new mint(0, MOD);
            if (n < 0 || k < 0) return new mint(0, MOD);
            return factorial[n].multiply(inverseFactorial[k]).multiply(inverseFactorial[n - k]);
        }

        //nPk
        public mint perm(int n , int k) {
            return comb(n ,k).multiply(fact(k));
        }

    }

}

class In {

    private final InputStream in = System.in;
    private final Scanner sc = new Scanner(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;
    }

    private  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 char nextChar() {
        return next().charAt(0);
    }

    public BigInteger nextBigInteger() {
        return sc.nextBigInteger();
    }

    public int [] nextInt(int n) {
        int [] array = new int[n];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = nextInt();
        }
        return array ;
    }

    public int [][] nextInt(int n , int m) {
        int [][] array = new int[n][m];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = nextInt(m);
        }
        return array ;
    }

    public long [] nextLong(int n) {
        long [] array = new long[n];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = nextLong();
        }
        return array ;
    }

    public long [][] nextLong(int n , int m) {
        long [][] array = new long[n][m];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = nextLong(m);
        }
        return array ;
    }

    public double [] nextDouble(int n) {
        double [] array = new double[n];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = nextDouble();
        }
        return array ;
    }
    
    public String [] next(int n) {
        String [] array = new String[n];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = next();
        }
        return array ;
    }

    public String [][] next(int n , int m) {
        String [][] array = new String[n][m];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = next(m);
        }
        return array ;
    }

    public char [] nextChar(int n) {
        char [] array = new char[n];
        String string = next() ;
        for(int i = 0 ; i < n ; i ++) {
            array[i] = string.charAt(i);
        }
        return array ;
    }

    public char [][] nextChar(int n , int m) {
        char [][] array = new char[n][m];
        for(int i = 0 ; i < n ; i ++) {
            array[i] = nextChar(m);
        }
        return array ;
    }

}