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
#include <bits/stdc++.h>

using namespace std;

struct Frog {
    int x, y, area;
};

struct Sprinkler {
    int x, y;
};

Sprinkler spr[10];
int graph[10][10];
int dx[] = {-1, 0, 1, 2, 2, 2, 1, 0, -1, -2, -2, -2};
int dy[] = {-2, -2, -2, -1, 0, 1, 2, 2, 2, 1, 0, -1};

void update(int area) {
    for(int i = spr[area].y - 1; i <= spr[area].y + 1; ++i) {
        for(int j = spr[area].x - 1; j <= spr[area].x + 1; ++j) {
            if(i >= 0 && i <= 9 && j >= 0 && j <= 9) {
                graph[i][j] = area;
            }
        }
    }
}

int main() {

    int x, y, n;

    while(cin >> x >> y, x | y) {

        cin >> n;

        for(int i = 0, spx, spy; i < n; ++i) {
            cin >> spr[i].x >> spr[i].y;
        }

        int alive = 0;
        queue<Frog> q;

        q.push((Frog){x, y, 0});
        memset(graph, -1, sizeof(graph));

        while(!q.empty()) {

            Frog now = q.front(); q.pop();

            if(now.area == n) {
                alive = 1;
                break;
            }

            update(now.area);

            for(int i = 0; i < 12; ++i) {
                Frog next = now;
                next.x += dx[i];
                next.y += dy[i];
                next.area++;
                if(next.x >= 0 && next.x <= 9 && next.y >= 0 && next.y <= 9) {
                    if(graph[next.y][next.x] == now.area) {
                        graph[next.y][next.x] = -1;
                        q.push(next);
                    }
                }
            }

        }

        cout << (alive ? "OK" : "NA") << endl;

    }

}