#include<cstdio>

#include<algorithm>

#include<cmath>

using namespace std;

int go[];

int nxt[];

int adj[];

int pos[];

int st[][];

int dep[];

int aa[];

int lg[];

int ecnt,cnt,m,n,s,x,y,a,b;

void add(int u,int v) {   //建链前

    go[++ecnt]=v;

    nxt[ecnt]=adj[u];

    adj[u]=ecnt;

}

void dfs(int u,int pre) {

    dep[u]=dep[pre]+;  //首先预处理出深度

    aa[++cnt]=u;  //DFS序

    pos[u]=cnt;   //第几个出现的

    for(int e=adj[u]; e; e=nxt[e]) {

        if(go[e]!=pre) {

            dfs(go[e],u);

            aa[++cnt]=u;

        }

    }

}

int MIN(int p,int q) {

    if(dep[p]<dep[q]) return p;

    else return q;

}

void build() {

    for(int i=; i<=cnt; i++) {

        st[i][]=aa[i];

    }

    for(int i = , j = ; i <= cnt; i++){

        if( << (j + ) == i) j++;

        lg[i] = j;

    }

    for(int j=; j<=lg[cnt]; j++) {

        for(int i=; i + ( << j) -  <=cnt; i++) {

            st[i][j]=MIN(st[i][j-],st[i+( << (j - ))][j-]);

        }

    }

}

/*

读入两个节点，查询它们第一次出现的位置

在这两个位置之间的区间查询最小深度的节点，该节点即为最近公共祖先

*/

int lca(int l,int r) {

    int xx=pos[l];

    int yy=pos[r];

    if(xx>yy) swap(xx,yy);

    int k=lg[yy-xx+];

    return MIN(st[xx][k],st[yy-( << k)+][k]);

}

template <class T>  //快速读入

void read(T &x){

    char c;

    bool op = ;

    while(c = getchar(), c < '' || c > '')

        if(c == '-') op = ;

    x = c - '';

    while(c = getchar(), c >= '' && c <= '')

        x = x *  + c - '';

    if(op) x = -x;

}

template <class T>  //快速输出

void write(T x){

    if(x < ) putchar('-'), x = -x;

    if(x >= ) write(x / );

    putchar('' + x % );

}

int main() {

    //scanf("%d%d%d",&n,&m,&s);

    read(n), read(m), read(s);

    for(int i=; i<=n-; i++) {

        //scanf("%d%d",&x,&y);

        read(x), read(y);

        add(x,y);

        add(y,x);

    }

    dfs(s,);

    build();

    for(int i=; i<=m; i++) {

        //scanf("%d%d",&a,&b);

        //printf("%d\n",lca(a,b));

        read(a), read(b);

        write(lca(a, b)), putchar('\n');

    }

    return ;

}

/*

倍增求LCA：

father【i】【j】表示节点i往上跳2^j次后的节点

可以转移为

father【i】【j】=father【father【i】【j-1】】【j-1】

（此处注意循环时先循环j，再循环i）

然后dfs求出各个点的深度depth

整体思路：

先比较两个点的深度，如果深度不同，先让深的点往上跳，浅的先不动，

等两个点深度一样时，if 相同 直接返回，if 不同 进行下一步；如果不同

，两个点一起跳，j从大到小枚举（其实并不大），如果两个点都跳这么多后

，得到的点相等，两个点都不动（因为有可能正好是LCA也有可能在LCA上方）

，知道得到的点不同，就可以跳上来，然后不断跳，两个点都在LCA下面那层，

所以再跳1步即可，当father【i】【j】中j=0时即可，就是LCA，返回值结束

*/

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<queue>

using namespace std;

vector <int> g[];

int father[][]={};

int depth[]={};

int n,m;

bool visit[]={false};

int root;

void dfs(int u)//深搜出各点的深度，存在depth中

{

    int i;

    visit[u]=true;

    for (i=;i<g[u].size();i++)

    {

        int v=g[u][i];

        if ( !visit[v] )

        {

            depth[v]=depth[u]+;

            dfs(v);

        }

    }

}

void bz()//fa数组的预处理

{

    int i,j;

    for (j=;j<=;j++)

        for (i=;i<=n;i++)

            father[i][j]=father[father[i][j-]][j-];

}//倍增，处理father数组，详情参照上述讲解

int LCA(int u,int v)

{

    if ( depth[u]<depth[v] )

    {

        int temp=u;

        u=v;

        v=temp;

    }//保证深度大的点为u，方便操作

    int dc=depth[u]-depth[v];

    int i;

    for (i=;i<;i++)//值得注意的是，这里需要从零枚举

    {

        if ( (<<i) & dc)//从大到小二分

        u=father[u][i];//意思是跳2^j步不一样，就跳，否则不跳

    }

    //上述操作先处理较深的结点，使两点深度一致

    if (u==v) return u;//如果深度一样时，两个点相同，直接返回

    for (i=;i>=;i--)//从大到小二分。

    {

        if (father[u][i]!=father[v][i])//跳2^j步不一样，就跳，否则不跳

        {

            u=father[u][i];

            v=father[v][i];

        }

    }

    u=father[u][];//上述过程做完，两点都在LCA下一层，所以走一步即可

    return u;

}

int main()

{

    int i,j;

    scanf("%d",&n);

    for (i=;i<=n;i++)

    g[i].clear();

    for (i=;i<n;i++)

    {

        int a,b;

        int root;

        scanf("%d%d",&a,&b);

        g[a].push_back(b);

        father[b][]=a;//a^0为1，所以fa[a][0]代表a向上走一格

        if (father[a][]==)//如果节点的根为0，证明该节点为根节点

        root = a;

    }

    depth[root]=;

    dfs(root);

    bz();

    int x,y;

    scanf("%d%d",&x,&y);

    printf("%d",LCA(x,y));

    return ;

}