#include <fstream>

#include <vector>

#include <algorithm>

#include <map>

using namespace std;

ifstream f("santa.in");

ofstream g("santa.out");

int N, S, E, Q, M;

map <int, int> Gr;

vector <int> G[45005], GG[45005];

bool Use[45005];

int Level[45005],Father[45005], nr, cnt;

int DP[(1 << 16) + 5][18];

pair <int, int> Link[(1 << 16) + 5][18];

vector <int> Bic[45005], Solution;

int nrc, yes = 0;

int Mark[45005];

int Artic[45005], Root,P[45005],Pos[45005], Inv[45005], St[45005], top2, a, b, c, limit, ending, bi;

int test, Power[20];

pair <int, int> Stack[200005];

int nbvis = 0;

int top;

bool ok = 1;

int Lmin[45005];

void Read()

{

    f >> N >> M;

    for(int i = 1; i <= M; i++)

    {

        int x, y;

        f >> x >> y;

        G[x].push_back(y);

        G[y].push_back(x);

    }

    f >> S >> E >> Q;

}

void Sol(int node, int neighb)

{

    ++nrc;

    while(top > 0 && !(Stack[top].first == node && Stack[top].second == neighb))

    {

        Bic[nrc].push_back(Stack[top].first);

        Bic[nrc].push_back(Stack[top].second);

        --top;

    }

    Bic[nrc].push_back(node);

    Bic[nrc].push_back(neighb);

    --top;

    Father[nrc] = node;

    sort(Bic[nrc].begin(), Bic[nrc].end());

    Bic[nrc].erase(unique(Bic[nrc].begin(), Bic[nrc].end()), Bic[nrc].end());

    /*int aux = 0;

    for(int i = 0; i < Bic[nrc].size(); i++)

    {

        int node = Bic[nrc][i];

        if(node == Q)

            aux++;

        if(node == S)

            aux++;

    }

    if(aux == 2)

        yes = 1;*/

}

void DFS(int node, int father)

{

    Use[node] = 1;

    int aux = 0;

    Level[node] = Level[father] + 1;

    Lmin[node] = Level[node];

 

    for(int i = 0; i < G[node].size(); i++)

    {

        int neighb = G[node][i];

        if(neighb == father)

            continue;

        if(Use[neighb] == 0)

        {

            aux++;

            Stack[++top] = make_pair(node, neighb);

            DFS(neighb, node);

            Lmin[node] = min(Lmin[neighb], Lmin[node]);

            if(Lmin[neighb] >= Level[node])

            {

                Sol(node, neighb);

                if(Artic[node] == 0 && node != 1)

                {

                    Artic[node] = ++nr; Inv[nr] = node;

                }

 

            }

 

        }

        else

        {

            Lmin[node] = min(Lmin[node], Level[neighb]);

        }

    }

    if(aux >= 2 && node == 1)

        Artic[node] = ++nr, Inv[nr] = node;

}

 

void precalcGG()

{

    Root = Artic[1] + nrc;

    for(int i = 1; i <= nrc; i++)

    {

        int father = Father[i];

        if(Artic[father] != 0)

        {

            GG[Artic[father] + nrc].push_back(i);

            GG[i].push_back(Artic[father] + nrc);

        Father[i] = Artic[father] + nrc;

        }

        else

            Father[i] = father = 0;

        for(int j = 0; j < Bic[i].size(); j++)

        {

            int node = Bic[i][j];

            if(node == father)

                continue;

            if(Artic[node] == 0)

                P[node] = i;

            if(Artic[node] != 0)

                {

                    GG[i].push_back(Artic[node] + nrc);

                    GG[Artic[node] + nrc].push_back(i);

                    Father[Artic[node] + nrc] = i;

                }

 

        }

    }

    cnt = nr + nrc;

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

    {

        sort(GG[i].begin(), GG[i].end());

        GG[i].erase(unique(GG[i].begin(), GG[i].end()), GG[i].end());

    }

}

int memor(int conf, int node)

{

    if(DP[conf][node] == -test)

        return 0;

    if(DP[conf][node] == test)

        return 1;

    if(conf == limit && (ending == 0 || Bic[bi][node] == ending))

    {

        DP[conf][node] = test;

        return 1;

    }

 

    for(int i = 0; i < G[Bic[bi][node]].size(); i++)

    {

        int neighb = G[Bic[bi][node]][i];

        if(Pos[neighb] != -1 && (conf & Power[Pos[neighb]]) == 0)

        {

            if(memor(conf ^ Power[Pos[neighb]], Pos[neighb]) == 1)

            {

                DP[conf][node] = test;

                Link[conf][node] = make_pair(conf ^ Power[Pos[neighb]], Pos[neighb]);

                return 1;

            }

        }

    }

    DP[conf][node] = -test;

    return 0;

}

void precalcRoad(int bic, int start, int fin)

{

    int lim = Bic[bic].size();

    ++test;

     bi = bic;

    /*for(int i = 0; i < (1 << lim); i++)

        for(int j = 0; j < lim; j++)

            DP[i][j] = 0, Link[i][j] = make_pair(0, 0);*/

    int ps = 0, pfin = 0;

    //Gr.clear();

    ending = fin;

    for(int i = 0; i < Bic[bic].size(); i++)

    {

        int node = Bic[bic][i];

        if(node == start)

            ps = i;

        if(node == fin)

            pfin = i;

        Pos[node] = i;

        //Gr[node] = 1;

    }

    limit = (1 << lim) - 1;

    ok = memor((1 << ps), ps);

    /*for(int i = 0; i < Power[lim]; i++)

    {

        for(int j = 0; j < lim; j++)

        {

            if(DP[i][j] != test)

                continue;

            for(int k = 0; k < G[Bic[bic][j]].size(); k++)

            {

                int p = G[Bic[bic][j]][k];

                /*if(Gr.find(p) == Gr.end())

                    continue;

                if(Pos[p] == -1)

                    continue;

                if((i & (Power[Pos[p]])) == 0)

                {

                    DP[i ^ (Power[Pos[p]])][Pos[p]] = test;

                    Link[i ^ (Power[Pos[p]])][Pos[p]] = make_pair(i, j);

                }

            }

        }

    }*/

 

    vector <int> X;

    int mask = (1 << lim) - 1, node = -1;

    /*if(fin == 0)

    {

        for(int j = 0; j < lim; j++)

            if(DP[mask][j] == test)

            {

                node = j;

                break;

            }

    }*/

    /*else

        node = pfin;*/

    if(DP[(1 << ps)][ps] == -test)

    {

        ok = 0;

        return;

    }

    mask = (1 << ps), node = ps;

    while(mask < (1 << lim))

    {

        Solution.push_back(Bic[bic][node]);

        int m = mask, n = node;

        if(mask == (1 << lim) - 1)

            break;

        mask = Link[m][n].first; node = Link[m][n].second;

 

    }

    /*reverse(X.begin(), X.end());

    for(int i = 0; i < X.size(); i++)

        Solution.push_back(Bic[bic][X[i]]);*/

    for(int i = 0; i < Bic[bic].size(); i++)

    {

        int p = Bic[bic][i];

        Pos[p] = -1;

    }

}

 

 

void Path()

{

    int last = b;

    bool first = 0;

    for(int i = 1; i <= top2 && ok == 1; i++)

    {

        int node = St[i];

        if(node > nrc)

        {

            last = Inv[node - nrc];

            continue;

        }

        if(first == 0)

        {

            first = 1;

            ok = 0;

            for(int j = 0; j < Bic[node].size(); j++)

                if(Bic[node][j] == a)

                    ok = 1;

        }

        bool in = 0;

        for(int j = 0; j < Bic[node].size(); j++)

            if(Bic[node][j] == c)

        {

            in = 1;

            break;

        }

        if(in == 1)

            precalcRoad(node, last, 0);

        else

            precalcRoad(node, last, Inv[St[i + 1] - nrc]);

    }

 

}

void DFS2(int node, int father)

{

    St[++top2] = node;

    if(node == E)

    {

        Path();

    }

    for(int i = 0; i < GG[node].size(); i++)

    {

        int neighb = GG[node][i];

        if(neighb == father)

            continue;

        DFS2(neighb, node);

    }

 

    --top2;

}

int main()

{

    Power[0] = 1;

    for(int i = 1; i <= 17; i++)

        Power[i] = Power[i - 1] * 2;

    Read();

    for(int i = 1; i <= N; i++)

        Pos[i] = -1;

    DFS(1, 0);

    precalcGG();

    a = S; b = Q; c = E;

    if(Artic[Q] == 0)

        Q = P[Q];

    else

        Q = Artic[Q] + nrc;

    if(Artic[E] == 0)

        E = P[E];

    else

        E = Artic[E] + nrc;

    if(Artic[S] == 0)

        S = P[S];

    else

        S = Artic[S] + nrc;

    DFS2(Q, 0);

    if(ok == 0)

    {

        g << "No chance\n";

 

    }

    else

    {

        Solution.erase(unique(Solution.begin(), Solution.end()), Solution.end());

        g << Solution.size() << "\n";

        for(int i = 0; i < Solution.size(); i++)

            g << Solution[i] << " ";

        g << "\n";

    }

    return 0;

}