#include <stdio.h>
#include <vector>

struct Splay {
  struct Node {
    int c[2], par;
    bool flip;
    Node(): par(0), flip(false) { c[0] = c[1] = 0; }
  };

  std::vector<Node> t;
  Splay( int n ): t(n + 1) {}

  void push_flip( int u ) {
    if( !u ) return;
    t[u].flip ^= 1;
  }

  void push( int u ) {
    if( t[u].flip ){
      std::swap( t[u].c[0], t[u].c[1] );
      t[u].flip = false;

      push_flip( t[u].c[0] );
      push_flip( t[u].c[1] );
    }
  }

  int side( int u ) {
    int p = t[u].par;
    if( t[p].c[0] == u ) return 0;
    if( t[p].c[1] == u ) return 1;
    return -1;
  }

  // doesn't take responsibility for pushes
  void link( int p, int u, int side ) {
    if( u ) t[u].par = p;
    if( p && ~side ) t[p].c[side] = u;
  }

  // both x and y must be pushed
  void zig( int x ) {
    int y = t[x].par, sx = side( x );
    int mij = t[x].c[!sx], up = t[y].par, sy = side( y );

    link( up, x, sy );
    link( x, y, !sx );
    link( y, mij, sx );
  }

  void splay( int x ) {
    while( side( x ) >= 0 ){
      int y = t[x].par;
      if( side( y ) < 0 ){
        push( y );
        push( x );
        zig( x );
        continue;
      }

      int z = t[y].par;
      push( z );
      push( y );
      push( x );

      int sx = side( x ), sy = side( y );      
      zig( sx == sy ? y : x );
      zig( x );
    }
  }
};

struct LinkCut : Splay {
  LinkCut( int n ): Splay(n) {}

  int expose( int uu ) {
    int u = uu, prev = 0;
    while( u ){
      splay( u );
      push( u );
      
      t[u].c[1] = prev; // cutoff right
      prev = u;
      u = t[u].par;
    }
    splay( uu );
    return prev;
  }

  void reroot( int u ) {
    expose( u );
    push_flip( u );
  }

  void Link( int u, int v ) {
    expose( u );
    reroot( v );
    t[v].par = u; // weak link
  }

  // assumes a and b are in same tree (wich is the case here)
  int Lca( int a, int b ) {
    expose( a );
    return expose( b );
  }
};

int main() {
  FILE *fin = fopen( "lca.in", "r" );
  FILE *fout = fopen( "lca.out", "w" );
  
  int n, q;
  fscanf( fin, "%d%d", &n, &q );

  LinkCut zile(n);
  for( int i = 2; i <= n; i++ ){
    int par;
    fscanf( fin, "%d", &par );
    zile.Link( par, i );
  }

  zile.reroot( 1 ); // conform enuntului
  for( int i = 0; i < q; i++ ){
    int a, b;
    fscanf( fin, "%d%d", &a, &b );
    fprintf( fout, "%d\n", zile.Lca( a, b ) );
  }

  fclose( fin );
  fclose( fout );
  return 0;
}