#include <bits/stdc++.h>

using namespace std;

const int N_MAX = 100005;
const int V_MAX = 100005;
const int Q_MAX = 100005;

class Query {  
   public:
      int iLeft;
      int iRight;
      int idx;
      
      Query(int _iLeft = 0, int _iRight = 0, int _idx = 0) :
         iLeft(_iLeft), iRight(_iRight), idx(_idx) {}
      bool operator <(const Query &o) const {
         return iLeft < o.iLeft;
      }
};

int N, Q;
int toRemove[N_MAX];
int lastOccurrence[V_MAX];
int tree[4 * N_MAX];
Query queries[Q_MAX];
int qans[Q_MAX];

void SegUpdate(int p, int v, int x, int l, int r) {
   if(p < l || r < p) return;
   if(l == r) {
      tree[x] = v;
      return;
   }
   int m = (l + r) >> 1;
   SegUpdate(p, v, x << 1, l, m);
   SegUpdate(p, v, x << 1 | 1, m + 1, r);
   tree[x] = max(tree[x << 1], tree[x << 1 | 1]);
}

int SegQuery(int i, int j, int x, int l, int r) {
   if(j < l || r < i) return 0;
   if(i <= l && r <= j) return tree[x];
   int m = (l + r) >> 1;
   return max(SegQuery(i, j, x << 1, l, m), SegQuery(i, j, x << 1 | 1, m + 1, r));
}

int main() {
   ifstream f("pq.in");
   ofstream g("pq.out");
   
   f >> N >> Q;
   
   for(int i = 1, v; i <= N; i++) {
      f >> v;
      if(lastOccurrence[v] > 0) {
         SegUpdate(i, i - lastOccurrence[v], 1, 1, N);
         toRemove[lastOccurrence[v] + 1] = i;
      }
      lastOccurrence[v] = i;
   }
   
   for(int i = 1, x, y; i <= Q; i++) {
      f >> x >> y;
      queries[i] = Query(x, y, i);
   }
   
   sort(queries + 1, queries + Q + 1);
   
   for(int i = 1, j = 1; i <= Q; i++) {
      while(j <= queries[i].iLeft) {
         if(toRemove[j]) {
            SegUpdate(toRemove[j], 0, 1, 1, N);
         }
         ++j;
      }
      int cAnswer = SegQuery(queries[i].iLeft, queries[i].iRight, 1, 1, N);
      if(cAnswer == 0) cAnswer = -1;
      qans[queries[i].idx] = cAnswer;
   }
   
   for(int i = 1; i <= Q; i++)
      g << qans[i] << '\n';
   
   return 0;
}