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:
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>

using namespace std;

typedef long long ll;
typedef pair<int,string> P;

static const double EPS = 1e-8;

class State {
public:
  int x;
  int cost;
  State(int x,int cost)
    : x(x), cost(cost) {}
  bool operator<(const State& s) const {
    return cost < s.cost;
  }
  bool operator>(const State& s) const {
    return cost > s.cost;
  }
};

int main(){
  int max_roulette_num;
  while(~scanf("%d",&max_roulette_num)){
    if(max_roulette_num == 0) break;

    int stage[320] = {};
    int total_cells;
    scanf("%d",&total_cells);
    for(int i = 0; i < total_cells; i++){
      int cell;
      scanf("%d",&cell);
      stage[i+1] = cell;
    }
    stage[0] = 0;
    stage[total_cells + 1] = 0;
    
    priority_queue<State,vector<State>,greater<State> > que;
    que.push(State(0,0));
    int dp[320];
    memset(dp,0x3f,sizeof(dp));
    dp[0] = 0;
    while(!que.empty()){
      State s = que.top();
      que.pop();
      for(int i = 1; i <= max_roulette_num; i++){
        int next = s.x + i;
        if(next > total_cells + 1) continue;
        next += stage[next];
        if(dp[next] <= s.cost + 1) continue;
        dp[next] = s.cost + 1;
        que.push(State(next,s.cost + 1));
      }
    }
    vector<int> starts;
    for(int i = 0; i <= total_cells + 1; i++){
      if(dp[i] < INF) starts.push_back(i);
    }

    bool has_unable = false;
    for(int start_i = 0; start_i < starts.size(); start_i++){
      int start = starts[start_i];
      memset(dp,0x3f,sizeof(dp));

      que.push(State(start,0));
      dp[start] = 0;
      while(!que.empty()){
        State s = que.top();
        que.pop();
        for(int i = 1; i <= max_roulette_num; i++){
          int next = s.x + i;
          if(next > total_cells + 1) continue;
          next += stage[next];
          if(dp[next] <= s.cost + 1) continue;
          dp[next] = s.cost + 1;
          que.push(State(next,s.cost + 1));
        }
      }

      if(dp[total_cells + 1] >= INF){
        has_unable = true;
        break;
      }
    }
    
    printf("%s\n", has_unable ? "NG" : "OK");
  }
}