Problem: School holidays come in Berland. The holidays are going to continue for n days. The students of school №N are having the time of their lives and the IT teacher Marina Sergeyevna, who has spent all the summer busy checking the BSE (Berland State Examination) results, has finally taken a vacation break! Some people are in charge of the daily watering of flowers in shifts according to the schedule. However when Marina Sergeyevna was making the schedule, she was so tired from work and so lost in dreams of the oncoming vacation that she perhaps made several mistakes. In fact, it is possible that according to the schedule, on some days during the holidays the flowers will not be watered or will be watered multiple times. Help Marina Sergeyevna to find a mistake.

Input

The first input line contains two numbers n and m (1 ≤ n, m ≤ 100) — the number of days in Berland holidays and the number of people in charge of the watering respectively. The next m lines contain the description of the duty schedule. Each line contains two integers ai and bi (1 ≤ ai ≤ bi ≤ n), meaning that the i-th person in charge should water the flowers from the ai-th to the bi-th day inclusively, once a day. The duty shifts are described sequentially, i.e. bi ≤ ai + 1 for all i from 1 to n - 1 inclusively. 

Output

Print "OK" (without quotes), if the schedule does not contain mistakes. Otherwise you have to find the minimal number of a day when the flowers will not be watered or will be watered multiple times, and output two integers — the day number and the number of times the flowers will be watered that day.

Examples

Input

10 5
1 2
3 3
4 6
7 7
8 10


Output

OK


Input

10 5
1 2
2 3
4 5
7 8
9 10


Output

2 2


Input

10 5
1 2
3 3
5 7
7 7
7 10


Output

4 0

Note

Keep in mind that in the second sample the mistake occurs not only on the second day, but also on the sixth day, when nobody waters the flowers. However, you have to print the second day, i.e. the day with the minimal number.

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;


public class Main {
     FastScanner in = new FastScanner(System.in);    
     PrintWriter out = new PrintWriter(System.out);
     
     public static void main(String[]args){      
         new Main().solve();         
     }
     
     void solve(){

         int n = in.nextInt();
         int m = in.nextInt();
         TreeMap<Integer, Integer>Q = new TreeMap<Integer,Integer>();
         for (int j = 0; j<m; j++){
             int a = in.nextInt();
             int b = in.nextInt();
             for (int i = a; i<=b; i++){
                 if(Q.containsKey(i)){
                     Q.put(i, Q.get(i) + 1);
                 }
                 else Q.put(i, 1);
             }       
         }
         
         Integer[]W = new Integer[Q.size()];
         W = Q.values().toArray(W);
         boolean breaker = false;
         for (int i = 0; i<W.length; i++){
             if (W[i]!=1){
                 breaker = true;
                 break;
             }
         }
         if (breaker == false && Q.size()==n){
             System.out.println("OK");
             return;
         }
         
         Integer[]T = new Integer[Q.size()];
         T = Q.keySet().toArray(T);
         if (T[0]!=1){
             System.out.println(1 + " " + 0);
             return;
         }

//       if (T.length!=n){
             for (int i = 0; i<T.length-1; i++){
                 if (W[i]!=1){
                     System.out.println(T[i] + " " + W[i]);
                     return;
                 }               
                 
                 if (T[i] + 1 != T[i + 1]){
                     System.out.println(T[i] + 1 + " " + 0);
                     return;
                 }
             }
//       }
         if (W[W.length-1]!=1){
             System.out.println(T[T.length-1] + " " + W[W.length-1]);
             return;
         }
         if (T[T.length-1]!=n){
             System.out.println(n + " " + 0);
             return;
         }

//       System.out.println(Q.entrySet());
     }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        FastScanner(InputStream in) {
            br = new BufferedReader(new InputStreamReader(in));
        }
        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    System.err.println(e);
                    return "";
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        float nextFloat(){
            return Float.parseFloat(next());
        }
        BigInteger nextBigInt(){
            return new BigInteger(next());
        }
        void close() {
            try {
                br.close();
            } 
            catch (IOException e) {
            }
        }       
}