The University of Aizu has a park covered with grass, and there are no trees or buildings that block the sunlight. On sunny summer days, sprinklers installed in the park operate to sprinkle water on the lawn. The frog Pyonkichi lives in this park. Pyonkichi is not good at hot weather, and on summer days when the sun is strong, he will dry out and die if he is not exposed to the water of the sprinkler. The sprinklers installed in the park are supposed to sprinkle only one sprinkler at a time to save water, so Pyonkichi must move according to the operation of the sprinklers.

<image>
---
(a) Map of the park

<image> | <image>
--- | ---
(b) Pyonkichi's jump range | (c) Sprinkler watering range



The park is as shown in (a) of the above figure, the location in the park is represented by the coordinates 0 to 9 in each of the vertical and horizontal directions, and the black ● is the sprinkler, which indicates the order in which the numbers operate. This is just an example, and the location and order of operation of each sprinkler changes daily.

Pyonkichi is clumsy, so he can only jump a certain distance to move. Pyonkichi's jumpable range is as shown in (b) above, and he cannot move to any other location. Moreover, one jump consumes a lot of physical strength, so you have to rest in the water for a while.

The range in which the sprinkler can sprinkle water is as shown in the above figure (c), including the coordinates of the sprinkler itself. Each sprinkler will stop after a period of watering, and the next sprinkler will start working immediately. Pyonkichi shall jump only once at this time, and shall not jump until the next watering stops. Also, since the park is surrounded on all sides by scorching asphalt, it is assumed that you will not jump in a direction that would cause you to go out of the park.

This summer was extremely hot. Was Pyonkichi able to survive? One day, read the initial position of Pyonkichi, the position of the sprinkler and the operation order, and if there is a movement path that Pyonkichi can survive, "OK", how? If you die even if you do your best, create a program that outputs "NA". However, the maximum number of sprinklers is 10, and Pyonkichi will jump from the initial position at the same time as the first sprinkler is activated.



Input

Given multiple datasets. Each dataset is given in the following format:


px py
n
x1 y1 x2 y2 ... xn yn


The first line gives the abscissa px and ordinate py of the initial position of Pyonkichi. The second line gives the number of sprinklers n. The third line gives the abscissa xi and the ordinate yi of the sprinkler that operates third.

The input ends with two zero lines. The number of datasets does not exceed 20.

Output

For each dataset, print OK if it is alive, or NA on one line otherwise.

Example

Input

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


Output

OK
NA

import java.awt.geom.Point2D;
import java.io.*;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Stack;
import java.util.TreeMap;



public class Main {

	static PrintWriter out = new PrintWriter(System.out);
	static FastScanner sc = new FastScanner();
	static Scanner stdIn = new Scanner(System.in);
	static int INF = 2 << 26;
	static int sx;
	static int sy;
	
	static int n;
	static int[] xlist;
	static int[] ylist;
	public static void main(String[] args) {
		while(true) {
			sx = sc.nextInt();
			sy = sc.nextInt();
			if(sy == 0 && sx == 0) break;
			n = sc.nextInt();
			xlist = new int[n];
			ylist = new int[n];
			for(int i = 0; i < n; i++) {
				xlist[i] = sc.nextInt();
				ylist[i] = sc.nextInt();
			}
			
			boolean ans = solv();
			if(ans) {
				out.println("OK");
			}
			else {
				out.println("NA");
			}
			
			
		}
		out.flush();
	}
	static ArrayDeque<Data> queue = new ArrayDeque<Data>();
	static boolean ans;
	static boolean solv() {
		ans = false;
		queue.isEmpty();
		
		queue.addLast(new Data(sy,sx,-1));
		
		while(!queue.isEmpty()) {
			bfs(queue.poll());
		}
		
		return ans;
	}
	
	static void bfs(Data a) {
		if(a.n == n) {
			ans = true;
			return;
		}
		if(!rCheck(a.y,a.x)) return;
		if(a.n == -1) {
			queue.addLast(new Data(a.y,a.x-2,a.n+1));
			queue.addLast(new Data(a.y,a.x+2,a.n+1));
			queue.addLast(new Data(a.y+2,a.x,a.n+1));
			queue.addLast(new Data(a.y-2,a.x,a.n+1));
			
			queue.addLast(new Data(a.y+2,a.x+1,a.n+1));
			queue.addLast(new Data(a.y+2,a.x-1,a.n+1));
			queue.addLast(new Data(a.y+1,a.x-2,a.n+1));
			queue.addLast(new Data(a.y+1,a.x+2,a.n+1));
			queue.addLast(new Data(a.y-1,a.x-2,a.n+1));
			queue.addLast(new Data(a.y-1,a.x+2,a.n+1));
			queue.addLast(new Data(a.y-2,a.x+1,a.n+1));
			queue.addLast(new Data(a.y-2,a.x-1,a.n+1));
			
			return;
		}
		
		if(!lCheck(a.y,a.x,a.n)) return;
		queue.addLast(new Data(a.y,a.x-2,a.n+1));
		queue.addLast(new Data(a.y,a.x+2,a.n+1));
		queue.addLast(new Data(a.y+2,a.x,a.n+1));
		queue.addLast(new Data(a.y-2,a.x,a.n+1));
		queue.addLast(new Data(a.y+2,a.x+1,a.n+1));
		queue.addLast(new Data(a.y+2,a.x-1,a.n+1));
		queue.addLast(new Data(a.y+1,a.x-2,a.n+1));
		queue.addLast(new Data(a.y+1,a.x+2,a.n+1));
		queue.addLast(new Data(a.y-1,a.x-2,a.n+1));
		queue.addLast(new Data(a.y-1,a.x+2,a.n+1));
		queue.addLast(new Data(a.y-2,a.x+1,a.n+1));
		queue.addLast(new Data(a.y-2,a.x-1,a.n+1));
	}
	
	static class Data {
		int y;
		int x;
		int n;
		
		Data(int a, int b, int c) {
			y = a;
			x = b;
			n = c;
		}
	}
	
	static boolean rCheck(int y, int x) {
		if(y > 9 || x > 9 || x < 0 || y < 0) return false;
		return true;
	}
	
	static boolean lCheck(int y, int x, int n) {
		int yr = ylist[n];
		int xr = xlist[n];
		
		if(y >= yr - 1 && y <= yr + 1 && x >= xr - 1 && x <= xr +1) {
			return true;
		}
		return false;
	}

}

//------------------------------//
//-----------//
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;}
    private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
    public boolean hasNext() { skipUnprintable(); 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() {
    	 if (!hasNext()) throw new NoSuchElementException();
         int 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 double nextDouble() {
    	return Double.parseDouble(next());
    }
    

}