#include <bits/stdc++.h>

using namespace std;

ifstream f("pq.in");
ofstream g("pq.out");

int arb[100100*4];

void update(int nod,int st,int dr,int pos,int val)
{
    if(st==dr)arb[nod]=max(arb[nod],val);
    else
    {
        int m=(st+dr)/2;
        if(pos<=m)update(2*nod,st,m,pos,val);
        else update(2*nod+1,m+1,dr,pos,val);

        arb[nod]=max(arb[2*nod],arb[2*nod+1]);
    }
}

int querry(int nod,int st,int dr,int a,int b)
{
    if(a<=st && dr<=b)return arb[nod];
    else
    {
        int m=(st+dr)/2,x1=0,x2=0;

        if(a<=m)x1=querry(2*nod,st,m,a,b);
        if(b>=m+1)x2=querry(2*nod+1,m+1,dr,a,b);

        return max(x1,x2);
    }
}

struct interval
{
    int l,r,ind,sol;
} a[100100];

int compare(interval A,interval B)
{
    if(A.r==B.r)return(A.l<B.l);
    return (A.r<B.r);
}

int compare_again(interval A,interval B)
{
    return (A.ind<B.ind);
}

int n,m,i,dif,indice_i,w,res,v[100100],last[100100];
int main()
{
    f>>n>>m;
    for(i=1; i<=n; i++)
    {
        f>>v[i];
    }

    for(i=1; i<=m; i++)
    {
        f>>a[i].l>>a[i].r;
        a[i].ind=i;
    }
    sort(a+1,a+m+1,compare); /// le sortez dupa marginea dreapta

    indice_i=1;w=1;
    while(w<=m)
    {
        while(indice_i<=a[w].r)
        {
         //   cout<<indice_i<<" "<<v[indice_i]<<" "<<last[v[indice_i]]<<'\n';
            if(last[v[indice_i]]!=0) /// daca am un nou interval caruia pot sa ii dau update ii dau. daca last[v[i]]=0 => ca e elem nou si as da update cu 0 (operatie useless)
            {
                dif=indice_i-last[v[indice_i]];
                update(1,1,n,last[v[indice_i]],dif); /// eu dau update pe pozitia last[v[indice_i]], deoarece stiu sigur ca distanta maxima caracterstica acelei pozitii este "dif"
                                                     /// asta e si motivul pentru care am sortat dupa r, pentru ca sa nu existe conflicte
                                                     /// daca nu sortam, putea sa existe urmatorul caz. De exemplu, eu dau cu acest algoritm update la pozitia 7, eu fiind pe pozitia 10
                                                     /// daca mi se cere minimul dintre 5 si 8, teoretic in arborele meu as lua in considerare distanta (7-10), care insa pentru 5-8 nu exista
                                                     /// in schimb, cum am sortat dupa R, nu va exista problema sa mi se ceara un interval al carui capat dreapta a fost calculat "in avans/prea mult".
            }
            last[v[indice_i]]=indice_i; /// dam update si la ultima pozitie pe care apare v[indice_i]
            indice_i++;
        }
        while(indice_i-1==a[w].r)
        {
            res=querry(1,1,n,a[w].l,a[w].r);
            if(res==0)a[w].sol=-1;
            else a[w].sol=res;
            w++;
        }
    }


    sort(a+1,a+m+1,compare_again);
    for(i=1;i<=m;i++)
        g<<a[i].sol<<'\n';
    return 0;
}