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 <iostream>
#include <stdio.h>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <set>
#include <math.h>
#include <utility>
#include <stack>
#include <string.h>
#include <complex>
using namespace std;
const int INF = 1<<29;
const double EPS = 1e-8;
typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int,int> P;
struct edge{int to,cost;};

const int dx[] = {0,0,1,-1};
const int dy[] = {1,-1,0,0};

int n, m;
int d[251];
vec G[252];
vec rG[252];
bool can_goal[252];
bool visited[252];

void dfs(int v){
    can_goal[v] = true;
    for(int i=0;i<rG[v].size();i++){
        if(!can_goal[rG[v][i]]) dfs(rG[v][i]);
    }
}

bool dfs2(int v){
    visited[v] = true;
    if(!can_goal[v]) return false;
    for(int i=0;i<G[v].size();i++){
        if(!visited[G[v][i]]&&!dfs2(G[v][i])){
            return false;
        }
    }
    return true;
}

void add_edge(int f,int t){
    G[f].push_back(t);
    rG[t].push_back(f);
}

int main(){
    while(cin >> m, m){
        cin >> n;

        for(int i=0;i<n+2;i++){
            G[i].clear();
            rG[i].clear();
        }
        d[0] = 0;
        for(int i=1;i<=n;i++){
            scanf("%d", &d[i]);
        }
        for(int i=0;i<n+1;i++){
            for(int j=1;j<=m;j++){
                if(i+j >= n+1 || i+j+d[i+j] >= n+1){
                    add_edge(i, n+1);
                }else{
                    add_edge(i, max(0, i+j+d[i+j]));
                }
            }
        }

        memset(can_goal, 0, sizeof(can_goal));
        dfs(n+1);
        memset(visited, 0, sizeof(visited));
        if(dfs2(0))cout << "OK" << endl;
        else cout << "NG" << endl;
    }
    return 0;
}