#include <fstream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

#define MAXN 45000

ifstream fin("santa.in");
ofstream fout("santa.out");

int n, m, s, e, q;
vector<int> gi[MAXN], g;

void citeste() {
    int i, j, a, b;
    fin >> n >> m;
    for (i = 1; i <= m; ++i) {
        fin >> a >> b;
        gi[a].push_back(b);
        gi[b].push_back(a);
    }
    fin >> s >> e >> q;
}

int how_high[MAXN], lv[MAXN], stiva[MAXN], viz[MAXN],  c;
int noduri[MAXN], failture = 0;
vector<int> comp[MAXN];
vector<int> candp[MAXN];

void adauga(int point) {
    ++c;
    noduri[c] = point;
    while (stiva[stiva[0]] != point) {
        comp[c].push_back(stiva[stiva[0]]);
        --stiva[0];
    }
    comp[c].push_back(stiva[stiva[0]]);
}

void do_biconex(int nod, int bk) {
    int i, mlev;
    viz[nod] = 1;
    lv[nod] = lv[bk] + 1;
    how_high[nod] = lv[nod];
    stiva[++stiva[0]] = nod;
    for (i = 0; i < gi[nod].size(); ++i) {
        if (viz[gi[nod][i]])
            how_high[nod] = min(how_high[nod], lv[gi[nod][i]]);
        else {
            do_biconex(gi[nod][i], nod);
            if (how_high[gi[nod][i]] < how_high[nod])
                how_high[nod] = how_high[gi[nod][i]];
            if (how_high[gi[nod][i]] == lv[nod])
                adauga(nod);
        }
    }
}
// nu uita verifica daca q nu este nod critic

int start, finish;

// creeaza graful de comp biconexe si stabileste start si finish
void do_magic_imbapro() {
    int i, j, whereS, whereD;
    for (i = 1; i <= c; ++i) {
        candp[i].push_back(noduri[i]);
        candp[c + noduri[i]].push_back(i)
    }
    for (i = 1; i <= c; ++i)
        for (j = 0; j < candp[i].size(); ++j) {
            if (candp[i][j] == s)
                whereS = i;
            if (candp[i][j] == d)
                whereD = i;
        }
    for (i = 1; i <= c; ++i)
        for (j = 0; j < candp[i].size(); ++j) {
            if (candp[i][j] == q)
                if (i != whereS && i != whereD) {
                    return 0;
                }
                else if (i == whereS) {
                    start = whereS;
                    finish = whereD;
                }
                else if (i == whereD) {
                    start = whereS;
                    finsh = whereD;
                }
        }
    return 1;
}

int ant[MAXN];
queue<int> musca_de_aur;

// fa lantul de comp biconexe
void mazga() {
    int elem, i, j;
    musca_de_aur.push(start);
    memset(viz, 0, sizeof(viz));
    while(!musca_de_aur.empty()) {
        elem = musca_de_aur.front();
        viz[elem] = 1;
        if (elem == finish)
            break;
        musca_de_aur.pop();
        for (i = 0; i < candp[elem].size(); ++i)
            if (!viz[candp[elem][i]]) {
                ant[candp[elem][i]] = elem;
                musca_de_aur.push(candp[elem][i]);
            }
        }
}

int drum[MAXN], nrelem;

// ciclu hamiltonian pt componenta conexa
void rainbow (int sdl, int nod, int fn) {
    int i;
    if (nod == fn && nrelem == comp[sdl].size() && nebunia_e_ok()) {
        moldova();
        return;
    }
    for (i = 0; i <= comp[sdl].size(); ++i) {
        
    }





}

// reconstituie lantul de comp biconexe
void fa_nebunie (int nod, int nfn) {
    int i, nst, nfn = d, nod = finish;
    memset(viz, 0, sizeof(viz));
    nrelem = 0;
    if (nod == start)
        rainbow (nod, s, nfn);
    else
        fa_nebunie(ant[ant[nod], ant[nod]);
    rainbow(nod, ant[nod], nfn);
}

int main() {
    int i, j;
    citeste();
    do_biconex(1, 0);
    if (!do_magic_imbapro()) {
        fout << "No chance\n";
        return 0;
    }
    mazga();
    fa_nebunie();
    return 0;
}