Problem: Taro made a sugoroku so that everyone can play at the children's association event. In order to make the game interesting, I wrote instructions such as "advance 6" and "back 5" in some of the sugoroku squares other than "Furidashi" and "Agari". Turn the roulette wheel to advance as many times as you can, and if an instruction is written on the stopped square, move according to that instruction. However, it does not follow the instructions of the squares that proceeded according to the instructions.

Roulette shall be able to give a number between 1 and a certain number with equal probability. Also, if you get a larger number than you reach "Agari", or if you follow the instructions and you go beyond "Agari", you will move to "Agari". If you follow the instructions and return before "Furidashi", you will return to "Furidashi".

<image>


However, depending on the instructions of the roulette wheel and the square, it may not be possible to reach the "rise". For example, let's say you made a sugoroku like the one shown in the figure. If you use a roulette wheel that only gives 1 and 2, you can go to "Agari" if you come out in the order of 1 and 2, but if you get 2 first, you will not be able to reach "Agari" forever no matter what comes out. Taro didn't know that and wrote instructions in various squares.

Therefore, on behalf of Taro, please create a program to determine whether or not you may not be able to reach the "rise" depending on the instructions of the roulette and the square.



input

The input consists of multiple datasets. The end of the input is indicated by a single zero line. Each dataset is given in the following format.


max
n
d1
d2
..
..
..
dn


The first line gives the maximum number of roulette wheels max (2 ≤ max ≤ 250), and the second line gives the number of cells other than "starting" and "rising" n (2 ≤ n ≤ 250). .. The next n lines are given the number di (-n ≤ di ≤ n) that represents the indication for each cell. When di is zero, it means that no instruction is written, when it is a positive number, it means | di | forward instruction, and when it is negative, it means | di | back instruction (where | x | is x). Represents an absolute value). All values ​​entered are integers.

The number of datasets does not exceed 100.

output

The judgment result is output to one line for each data set. Depending on the instructions of the roulette and the square, if it may not be possible to reach the "go up", "NG" is output, otherwise "OK" is output.

Example

Input

3
3
-2
1
0
2
4
2
0
-1
-2
2
2
-2
-2
0


Output

OK
NG
NG

Solution (in CPP):

Solution:
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000001
using namespace std;

struct Info{
	Info(int arg_count,int arg_loc){
		count = arg_count;
		loc = arg_loc;
	}
	int count,loc;
};

void func(int MAX,int N){

	int min_Count_Base[N+2];
	int min_Count_Work[N+2];
	int instruction[N+2];

	for(int i = 1; i <= N; i++){
		scanf("%d",&instruction[i]);
		min_Count_Base[i] = BIG_NUM;
	}

	min_Count_Base[0] = 0;
	min_Count_Base[N+1] = BIG_NUM;

	instruction[0] = 0;
	instruction[N+1] = 0;

	int next_loc;

	queue<Info> Q;
	Q.push(Info(0,0));

	while(!Q.empty()){

		if(Q.front().loc == N+1){
			Q.pop();
		}else if(Q.front().count > min_Count_Base[Q.front().loc]){
			Q.pop();
		}else{

			for(int i = 1; i <= MAX; i++){
				next_loc = Q.front().loc+i;

				if(next_loc > N+1){
					next_loc = N+1;
				}else if(next_loc < 0){
					next_loc = 0;
				}

				next_loc += instruction[next_loc];

				if(next_loc > N+1){
					next_loc = N+1;
				}else if(next_loc < 0){
					next_loc = 0;
				}

				if(min_Count_Base[next_loc] > Q.front().count+1){
					min_Count_Base[next_loc] = Q.front().count+1;
					Q.push(Info(Q.front().count+1,next_loc));
				}
			}

			Q.pop();
		}
	}

	if(min_Count_Base[N+1] == BIG_NUM){
		printf("NG\n");
		return;
	}

	bool FLG = true;

	for(int start = 1; start <= N; start++){
		if(min_Count_Base[start] != BIG_NUM){

			for(int i = 0; i <= N+1; i++){
				min_Count_Work[i] = BIG_NUM;
			}

			min_Count_Work[0] = 0;

			Q.push(Info(0,start));

			while(!Q.empty()){

				if(Q.front().loc == N+1){
					Q.pop();
				}else if(Q.front().count > min_Count_Work[Q.front().loc]){
					Q.pop();
				}else{

					for(int i = 1; i <= MAX; i++){
						next_loc = Q.front().loc+i;

						if(next_loc > N+1){
							next_loc = N+1;
						}else if(next_loc < 0){
							next_loc = 0;
						}

						next_loc += instruction[next_loc];

						if(next_loc > N+1){
							next_loc = N+1;
						}else if(next_loc < 0){
							next_loc = 0;
						}

						if(min_Count_Work[next_loc] > Q.front().count+1){
							min_Count_Work[next_loc] = Q.front().count+1;
							Q.push(Info(Q.front().count+1,next_loc));
						}
					}

					Q.pop();
				}
			}

			if(min_Count_Work[N+1] == BIG_NUM){
				FLG = false;
				break;
			}
		}
	}


	if(!FLG){
		printf("NG\n");
	}else{
		printf("OK\n");
	}
}

int main(){

	int MAX,N;
	while(true){
		scanf("%d",&MAX);
		if(MAX == 0)break;

		scanf("%d",&N);
		func(MAX,N);
	}

	return 0;
}