#include<bits/stdc++.h>
 
 
using namespace std;
using ii = pair < int , int >;
 
const int N = 1e5 + 5;
 
 
int n;
int s , d;
 
int code  (int x){ return x + n + 1; }
int decode(int x){ return x - n - 1; }
 
 
int low[N] , dfn[N];
int timer = 0 , bcc_count = 0;
int parent[N];
bool cut[N];
 
 
vector < int > adj[N] , Tree[N];
 
set < int > BCC[N];
set < int > belong[N];
set < int > ans;
 
vector < ii > edges_stack;
 
/// find bi-connected components /////////////////////////////////
 
 
void make_BCC(int u , int v){
    if(edges_stack.size() == 0)return;
    bcc_count ++;
 
    ii E = {u , v};
 
    while( !edges_stack.empty() ){
        ii E2 = edges_stack.back(); edges_stack.pop_back();
 
        int x = E2.first;
        int y = E2.second;
 
        BCC[bcc_count].insert(x);
        BCC[bcc_count].insert(y);
 
        belong[x].insert(bcc_count);
        belong[y].insert(bcc_count);
 
        if(E2 == E)break;
    }
}
 
void dfs(int u , int p){
    dfn[u] = low[u] = ++ timer;
    int children = 0;
 
    for(int v : adj[u]){
 
        if(dfn[v] == 0){
            children ++;
            edges_stack.push_back({u , v});
 
            dfs(v , u);
 
            low[u] = min(low[u] , low[v]);
 
            if( (p == -1 && children > 1) || (p != -1 && dfn[u] <= low[v]) ){
                cut[u] = 1;
                make_BCC(u , v);
            }
 
        }
        else if(v != p){
            if(dfn[v] < low[u]){
                low[u] = dfn[v];
                edges_stack.push_back({u , v});
            }
        }
    }
}
 
/// ///////////////////////////////////////////////////////////
 
/// build bi-connected components Tree ////////////////////////
 
/// connect each cut point to all component it belongs to
void build_BCC_Tree(){
 
    for(int i = 0 ; i < n ; i ++){
        if(cut[i]){
            for(int b : belong[i]){
                int v = code(b);
 
                Tree[i].push_back(v);
                Tree[v].push_back(i);
            }
        }
    }
 
}
 
/// ///////////////////////////////////////////////////////////
 
 
/// dfs the bi-connected components Tree
 
void dfs_Tree(int u , int p){
    parent[u] = p;
 
    for(int v : Tree[u])if(v != p)dfs_Tree(v , u);
}
 
 
main(){
    scanf("%d" , &n);
 
    for( ; ; ){
        int u , v;
 
        scanf("%d %d" , &u , &v);
        if(u == -1 && v == -1)break;
 
        adj[u].push_back(v);
        adj[v].push_back(u);
 
    }
    scanf("%d %d" , &s , &d);
 
    /// same city
    if(s == d){
        printf("%d\n" , s);
        return 0;
    }
 
    for(int i = 0 ; i < n ; i ++){
        if(dfn[i] == 0){
            dfs(i , -1);
            make_BCC(-1 , -1);
        }
    }
 
    build_BCC_Tree();
 
    /// s is not a cut point so work with its bi-connected component
    if(!cut[s])s = code(*(belong[s].begin()));
 
    /// same for d
    if(!cut[d])d = code(*(belong[d].begin()));
 
    dfs_Tree(s , -1);
 
    /// now get the path from d to s
    while( true ){
        /// a cut point
        if(d < n)ans.insert(d);
 
        /// a bi-connected component
        else {
            int comp = decode(d);
            for(int B : BCC[comp])ans.insert(B);
        }
        if(d == s)break;
        d = parent[d];
        if(d == -1)break;
    }
 
    int i = 0;
    int sz = ans.size();
    for(auto it = ans.begin() ; it != ans.end() ; it ++ , i ++){
        printf("%d%s" , *it , i == sz-1 ? "" : " ");
    }
 
    return 0;
}