#include <iostream>
#include <vector>
#include <fstream>
#include <stdlib.h>
using namespace std;
int n,nrop;
int nivel[100000];
int *primaaparitie;
vector <int> euler;
vector <vector <int> > arbore;
vector <vector <int> > RMQ;
ifstream in("lca.in");
ofstream out("lca.out");



int nivel_min(int a,int b)
{
    if(nivel[a]<nivel[b])return a;
    return b;
}

int putere_2(int n,int x=1)
{
    if(n==0)return x;
    else return putere_2(n-1,2*x);
}
int log_2(int x){
if(x==1)return 0;
int i=1;
while(putere_2(i)<x)i++;
if(putere_2(i)==x)return i;
return i-1;
}


void generare_euler(int n)
{
    primaaparitie[n]=euler.size();
    euler.push_back(n);
    vector <int> forRMQ;
    RMQ.push_back(forRMQ);
    if(arbore[n].size()>0)
    {
        for(unsigned int i=0; i<arbore[n].size(); i++)
        {
            generare_euler(arbore[n][i]);
            euler.push_back(n);
            RMQ.push_back(forRMQ);
        }
    }
}


void rmq()
{
    for(unsigned int i=0; i<euler.size(); i++)
    {
        RMQ[i].push_back(euler[i]);
    }
    for(unsigned int i=1; putere_2(i)<euler.size(); i++)
    {
        for(unsigned int j=0; putere_2(i)+j<euler.size(); j++)
        {
            RMQ[j].push_back(nivel_min(RMQ[j][i-1],RMQ[j+putere_2(i-1)][i-1]));
        }
    }
}


void lca(int a,int b)
{
    if(primaaparitie[a]>primaaparitie[b])
    {
        a=a^b;
        b=a^b;
        a=a^b;
    }
    int niv_min=RMQ[primaaparitie[a]][0];
    int dif=primaaparitie[b]-primaaparitie[a];
    int i=log_2(dif);
    niv_min=nivel_min(RMQ[primaaparitie[a]][i],RMQ[primaaparitie[b]-putere_2(i)][i]);


   // int iter=primaaparitie[a];




    /*while(dif)
    {
        if(dif&(1<<i))
        {
            dif=dif&~(1<<i);
            niv_min=nivel_min(niv_min,RMQ[iter][i]);
            iter+=putere_2(i);
        }
        i++;
    }*/
    out<<niv_min+1<<endl;
}
int main()
{
    nivel[0]=0;
    in>>n>>nrop;
    primaaparitie=(int*)malloc(n*4+20);
    int x;
    vector <int> a;
    arbore.push_back(a);
    for(int i=1; i<n; i++)
    {
        in>>x;
        arbore[x-1].push_back(i);
        nivel[i]=nivel[x-1]+1;
        vector <int> aux;
        arbore.push_back(aux);
    }
    generare_euler(0);
    rmq();
    for(int i=0; i<nrop; i++)
    {
        int a,b;
        in>>a>>b;
        lca(a-1,b-1);
    }
    free(primaaparitie);

    cout<<log_2(4);
    return 0;
}