One cold winter evening Alice and her older brother Bob was sitting at home near the fireplace and giving each other interesting problems to solve. When it was Alice's turn, she told the number n to Bob and said:

—Shuffle the digits in this number in order to obtain the smallest possible number without leading zeroes.

—No problem! — said Bob and immediately gave her an answer.

Alice said a random number, so she doesn't know whether Bob's answer is correct. Help her to find this out, because impatient brother is waiting for the verdict.

Input

The first line contains one integer n (0 ≤ n ≤ 109) without leading zeroes. The second lines contains one integer m (0 ≤ m ≤ 109) — Bob's answer, possibly with leading zeroes.

Output

Print OK if Bob's answer is correct and WRONG_ANSWER otherwise.

Examples

Input

3310
1033


Output

OK


Input

4
5


Output

WRONG_ANSWER
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.Locale;
import java.util.SortedSet;
import java.util.TreeSet;

public class B12 
{
    public static void main(String[] args) throws IOException 
    {
        setStandardIO();
        //setFileIO("b12");     
        
        String a = nextString();
        String b = nextString();
        
        SortedSet<String> ss = new TreeSet<String>();
        for (int i = 0; i < a.length(); i++)
            if (a.charAt(i) != '0')
                ss.add(a.substring(i) + a.substring(0, i));
        
        println(ss.first().equals(b) ? "OK" : "WRONG_ANSWER");
        flush();
    }

    // ~ -----------------------------------------------------------------------
    // ~ - Auxiliary code ------------------------------------------------------
    // ~ -----------------------------------------------------------------------
    static InputStream in;
    static PrintWriter out;

    /**
     * Simple buffered reader class. Reads if buffer is empty. Try to fill up
     * whole buffer.
     */
    public static class SimpleBufferedInputStream extends InputStream 
    {
        // ~ Static fields / Initializers --------------------------------------
        private static int defaultCharBufferSize = 16384;
        private InputStream in;
        byte[] buffer;
        int pos = 0;
        int len = 0;
        
        // ~ Constructors ------------------------------------------------------
        public SimpleBufferedInputStream(InputStream in) {
            this(in, defaultCharBufferSize);
        }

        public SimpleBufferedInputStream(InputStream in, int size) {
            this.in = in;
            this.buffer = new byte[size];
        }
        
        // ~ Methods -----------------------------------------------------------
        @Override
        public int read() throws IOException {
            if (pos < len)
                return buffer[pos++];
            
            len = in.read(buffer);
            if (len == -1)
                return len;
            
            pos = 0;
            if (len <= 0)
                return -1;
            
            return buffer[pos++];
        }
    }

    public static void setStandardIO() {
        in = new SimpleBufferedInputStream(System.in);
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    }

    public static void setFileIO(String fileName) throws IOException {
        in = new SimpleBufferedInputStream(new FileInputStream(fileName + ".in"));
        out = new PrintWriter(new BufferedWriter(new FileWriter(fileName + ".out")));
    }

    public static int skipWhitespaces() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (c == -1) throw new IOException();
            if (!isWhitespace(c)) break;
        }   
        
        return c;
    }
    
    public static int skipNewLines() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (c == -1) throw new IOException();
            if (!isNewLine(c)) break;
        }   
        
        return c;
    }

    public static boolean isNewLine(int c) {
        return c == '\n' || c == '\r' ? true : false;
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' ? true : false;
    }
    
    public static int nextNoWhitespace() throws IOException {
        int c = in.read();
        if (c == -1 || isWhitespace(c)) return -1;
        
        return c;
    }

    public static int nextNoNewLine() throws IOException {
        int c = in.read();
        if (c == -1 || isNewLine(c)) return -1;
        
        return c;
    }

    public static long nextLong() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (!isWhitespace(c)) break;
            if (c == -1) throw new RuntimeException();
        }   

        boolean neg = false;
        long val = 0;
        if (c == '-')
            neg = true;
        else 
            val = c - '0';
        
        for (;;) {
            c = in.read();
            if (isWhitespace(c) || c == -1) 
                break;
            
            val = val * 10 + (c - '0');
        }

        if (neg) 
            return -val;
        
        return val;
    }

    public static int nextInt() throws IOException {
        int c;
        for (;;) {
            c = in.read();
            if (!isWhitespace(c)) break;
            if (c == -1) throw new RuntimeException();
        }   
        
        boolean neg = false;        
        int val = 0;
        if (c == '-')
            neg = true;
        else 
            val = c - '0';
        
        for (;;) {
            c = in.read();
            if (isWhitespace(c) || c == -1) 
                break;
            
            val = val * 10 + (c - '0');
        }

        if (neg) 
            return -val;
        
        return val;
    }

    public static byte nextByte() throws IOException {
        return (byte) nextInt();
    }

    public static String nextLine() throws IOException {
        int c = (char) skipNewLines();
        
        StringBuilder sb = new StringBuilder();
        sb.append((char) c);
        
        for (;;) {
            c = nextNoNewLine();
            if (c == -1)
                break;
            
            sb.append((char) c);
        }

        return sb.toString();
    }

    public static String nextString() throws IOException {
        int c = (char) skipWhitespaces();
        
        StringBuilder sb = new StringBuilder();
        sb.append((char) c);
        
        for (;;) {
            c = nextNoWhitespace();
            if (c == -1)
                break;
            
            sb.append((char) c);
        }

        return sb.toString();
    }

    public static double nextDouble() throws IOException {
        return Double.parseDouble(nextString());
    }   
    
    public static BigDecimal nextBigDecimal() throws IOException {
        return new BigDecimal(nextString());
    }
    
    public static void flush() {
        out.flush();
    }

    public static void println(Object object) {
        out.println(object);
    }

    public static void print(Object object) {
        out.print(object);
    }

    public static void println(double d, int precision) {
        String s = "%1$." + precision + "f";
        out.format(Locale.ENGLISH, s, d);
        out.println();
    }

    public static void println(BigDecimal d, int precision) {
        String s = "%1$." + precision + "f";
        out.format(Locale.ENGLISH, s, d);
        out.println();
    }
}
