#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <vector>
#include <cmath>
#include <algorithm>
#include <set>

enum TYP { typhs, typv, typhe };

struct event
{
  int t;
  TYP typ;

  int start, end;
  int druha;
  int step;
  bool operator< (const event& rhs) const
  {
    if (t < rhs.t)
      return true;
    if (typ < rhs.typ)
      return true;
    if (step < rhs.step)
      return true;
    return false;
  }
};

struct findevent
{
  bool operator()(const event& e1, const event& e2)
  {
    return e1.step < e2.step;
  }
};

std::vector<event> events;
std::set<event, findevent> hevents;

int main()
{
  int num;
  events.reserve(1000000);
  while (scanf("%d", &num) == 1)
  {
    events.clear();
    hevents.clear();
    int x = 0, y = 0;
    int orient = 0;
    for (int i = 0; i < num; i++)
    {
      int segment;
      scanf("%d", &segment);
      int lastx = x, lasty = y;
      switch (orient)
      {
	case 0: y += segment; break;
	case 1: x += segment; break;
	case 2: y -= segment; break;
	case 3: x -= segment; break;
      }
      event e;
      switch (orient)
      {
	case 1:
	case 3:
	  e.start = std::min(lastx, x);
	  e.end = std::max(lastx, x);
	  e.step = i;
	  e.druha = y;

	  e.typ = typhs;
	  e.t = e.start;
          events.push_back(e);
	  e.typ = typhe;
	  e.t = e.end;
          events.push_back(e);
	  break;
	case 2: 
	case 0: 
	  e.start = std::min(lasty, y);
	  e.end = std::max(lasty, y);
	  e.step = i;
	  e.druha = x;

	  e.typ = typv;
	  e.t = x;
          events.push_back(e);
	  break;
      }

      orient++;
      if (orient == 4)
	orient = 0;
    }
    std::sort(events.begin(), events.end());

    int problem = 10000000;
    for (int i = 0; i < (int)events.size(); i++)
    {
      event& e = events[i];
      switch (e.typ)
      {
	case typhs:
	  hevents.insert(e);
	  break;
	case typhe:
	  //hevents.erase(hevents.find(e));
	  break;
	case typv:
	  for (std::set<event, findevent>::iterator it = hevents.begin();
	      it != hevents.end(); it++)
	  {
	    const event& he = *it;
	    if (he.druha >= e.start && he.druha <= e.end && 
		std::abs(he.step - e.step) != 1 &&
		he.start <= e.druha && he.end >= e.druha)
	    {
	      int foundstep = std::max(he.step, e.step);
	      if (foundstep < problem)
	      {
		problem = foundstep;
	      }
	    }
	  }
	  break;
      }
    }
    if (problem < 10000000)
      printf("%d\n", problem);
    else
      printf("OK\n");
  }
  return 0;
}