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

#define MAX 1010000

struct intp {
	int a,b;
};

struct da {
	int *data;
	int pocet;
};

struct query{
	int min, max;
};

struct res {
	struct da use, dup;
};

struct res *rs[100];

int msgs[MAX];
struct query ques[MAX];
int nmsg, nque;

void da_init(struct da *d, int poc)
{
	//printf("%p\n", d);
	d->pocet = 0;
	d->data = malloc(sizeof(d->data[0]) * poc);
}

void da_add(struct da *d, int n)
{
	d->data[d->pocet++] = n;
}

int da_get(struct da *d, int n)
{
	if (d->pocet > n) return d->data[n];
	return INT_MAX;
}

void da_dup(struct da *d, struct da *s)
{
	int i;
	for (i=0; i<s->pocet; i++) {
		da_add(d, da_get(s, i));
	}
}

void initres(void)
{
	int x = MAX, i=0, j, mx = 1;
	while (x) {
		rs[i] = malloc(sizeof(rs[0][0]) * x);
		/*printf("malloc s=%d %p\n", sizeof(rs[0]) * x, rs[i]);*/
		for (j=0; j<x; j++) {
			/*if ((j%10000)==0) printf("j=%d\n", j);*/
			da_init(&(rs[i][j].use), mx);
			da_init(&(rs[i][j].dup), mx);
		}
		i++;
		mx = mx << 1;
		x = x >> 1;
	}
}

void reset(void)
{
	int x=MAX, i=0, j;
	while (x) {
		for (j=0; j<x; j++) {
			rs[i][j].use.pocet = 0;
			rs[i][j].dup.pocet = 0;
		}
		i++;
		x = x >> 1;
	}
}

void mrg(struct res *d, struct res *s1, struct res *s2)
{
	int u1 = 0, u2 = 0, d1 = 0, d2 = 0;
	int s1u, s2u, s1d, s2d;
	int min, cp;
	while (1) {
		s1u = da_get(&(s1->use),u1);
		s2u = da_get(&(s2->use),u2);
		s1d = da_get(&(s1->dup),d1);
		s2d = da_get(&(s2->dup),d2);
		
		min = s1d;
		if (min > s2d) min = s2d;
		if (min > s1u) min = s1u;
		if (min > s2u) min = s2u;
		if (min == INT_MAX) break;
		
		cp = 0;
		if (min == s1u) { cp++; u1++; };
		if (min == s2u) { cp++; u2++; };
		if (min == s1d) { cp=2; d1++; };
		if (min == s2d) { cp=2; d2++; };
		
		if (cp > 1) {
			da_add(&(d->dup), min);
		} else {
			da_add(&(d->use), min);
		}
	}
}

void da_pr(struct da *d)
{
	int i;
	for (i=0; i<d->pocet; i++)
		printf("%d ", d->data[i]);
}

void prn(struct res *r)
{
	printf("use: ");
	da_pr(&(r->use));
	printf("dup: ");
	da_pr(&(r->dup));
	printf("\n");
}

void bld(void)
{
	int x=MAX, i=0, j;
	while (x) {
		if (i==0) {
			for (j=0; j<x; j++) {
				if (j < nmsg)
					da_add(&(rs[i][j].use), msgs[j]);
			}
		} else {
			for (j=0; j<x; j++) {
				mrg(&(rs[i][j]), &(rs[i-1][j*2]), &(rs[i-1][j*2+1]));
				if (rs[i][j].use.pocet || rs[i][j].dup.pocet) {
					/*printf("%d %d: ", i, j);
					prn(&(rs[i][j]));*/
				}
			}
		}
		i++;
		x = x >> 1;
	}
}

void pre(int lev, int i, int min, int max, struct res *re)
{
	int bmi, bma, bs;
	struct res re1, re2;
	
	/*printf(">> %d %d %d %d %p\n", lev, i, min, max, re);*/
	
	bs = 1 << lev;
	bmi = i * bs;
	bma = bmi + bs - 1;
	/*printf("** bs=%d bmi=%d bma=%d\n", bs, bmi, bma);
	printf("** min=%d max=%d\n", min, max);*/
	if (max < bmi || min > bma) return;
	if (max >= bma && min <= bmi) {
		da_dup(&(re->dup), &(rs[lev][i].dup));
		da_dup(&(re->use), &(rs[lev][i].use));
	} else {
		da_init(&(re1.dup), MAX);
		da_init(&(re1.use), MAX);
		da_init(&(re2.dup), MAX);
		da_init(&(re2.use), MAX);
		pre(lev - 1, 2 * i, min, max, &re1);
		pre(lev - 1, 2 * i + 1, min, max, &re2);
		mrg(re, &re1, &re2);
		free(re1.dup.data);
		free(re1.use.data);
		free(re2.dup.data);
		free(re2.use.data);
	}
}

void pres()
{
	int nq;
	
	struct res re;
	
	da_init(&(re.dup), MAX);
	da_init(&(re.use), MAX);
	
	for (nq=0; nq<nque; nq++) {
		/*printf("**pres:%d\n", nq);*/
		re.dup.pocet = 0;
		re.use.pocet = 0;
		pre(20, 0, ques[nq].min - 1, ques[nq].max - 1, &re);
		/*prn(&re);*/
		if (re.dup.pocet == 0)
			printf("OK\n");
		else
			printf("%d\n", re.dup.data[0]);
	}
	printf("\n");
	free(re.dup.data);
	free(re.use.data);
}


int main(void)
{
	int i;
	initres();
	while (1) {
		scanf("%d %d\n", &nmsg, &nque);
		if (!nmsg && !nque) break;
		for (i=0; i<nmsg; i++)
			scanf("%d\n", msgs + i);
		for (i=0; i<nque; i++)
			scanf("%d %d\n", &(ques[i].min), &(ques[i].max));
		/*printf("%d %d\n", nmsg, nque);*/
		reset();
		bld();
		pres();
	}
	return 0;
}