#include <bits/stdc++.h>

#define int long long

#define pii pair<int, int>

#define x1 x1228
#define y1 y1228

#define left left228
#define right right228

#define pb push_back
#define eb emplace_back

#define mp make_pair

#define ff first
#define ss second

#define matr vector<vector<int> >

#define all(x) x.begin(), x.end()


using namespace std;
typedef long long ll;
typedef long double ld;

const int maxn = 3e5 + 7, mod = 1e9 + 7, inf = 1e18, MAXN = 1e6 + 7;
const double eps = 1e-9;
mt19937 rnd(time(0));
struct edge {
    int a, b, f, c, id;
};

vector<edge> e;
int pt[maxn];
vector<int> gr[maxn];
int d[maxn];
int lim;
int s, t, ptr;

inline void add_edg(int a, int b, int c, int i) {
    edge ed;
    ed.a = a; ed.b = b; ed.f = 0; ed.c = c, ed.id = i;
    gr[a].push_back(e.size());
    e.push_back(ed);
    ed.a = b; ed.b = a; ed.f = 0; ed.c = 0, ed.id = i;
    gr[b].push_back(e.size());
    e.push_back(ed);
}

inline bool bfs() {
    queue<int> q;
    for (int i = 0; i < ptr; i++)
        d[i] = inf;
    d[s] = 0;
    q.push(s);
    while (!q.empty() && d[t] == inf) {
        int cur = q.front(); q.pop();
        for (size_t i = 0; i < (int)gr[cur].size(); i++) {
            int id = gr[cur][i];
            int to = e[id].b;
            if (d[to] == inf && e[id].c - e[id].f >= lim) {
                d[to] = d[cur] + 1;
                q.push(to);
            }
        }
    }
    while (!q.empty())
        q.pop();
    return d[t] != inf;
}

inline int dfs(int v, int flow) {
    if (flow == 0)
        return false;
    if (v == t)
        return true;
    for (; pt[v] < gr[v].size(); pt[v]++) {
        int id = gr[v][pt[v]];
        int to = e[id].b;
        if (d[to] == d[v] + 1 && e[id].c - e[id].f >= flow) {
            int pushed = dfs(to, flow);
            if (pushed) {
                e[id].f += flow;
                e[id ^ 1].f -= flow;
                return true;
            }
        }
    }
    return false;
}

int n, m, a, h;

int dinic() {
    ptr = 3 * n;
    int flow = 0;
    for (lim = (1 << 0); lim >= 1;) {
        if (flow == 2) {
            break;
        }
        if (!bfs()) {
            lim >>= 1;
            continue;
        }
        for (int i = 0; i < ptr; i++)
            pt[i] = 0;
        while (dfs(s, lim)) {
            flow = flow + lim;
            if (flow == 2) {
                break;
            }
        }
    }
    return flow;
}

set<int> have;

void get(int u, vector<int> &ans) {
    vector<int> dist(n, inf);
    vector<pii> pr(n, {-1, -1});
    dist[s] = 0;
    deque<int> q = {s};
    while (q.size()) {
        int u = q.front();
        q.pop_front();
        for (auto v : gr[u]) {
            edge hui = e[v];
            if (hui.c != 0 && hui.f == 1 && have.count(hui.id) == 0 && dist[hui.b] == inf) {
                dist[hui.b] = dist[u] + 1;
                q.pb(hui.b);
                pr[hui.b] = {u, hui.id};
            }
        }
    }
    int lst = t;
    while (lst != -1) {
        ans.pb(lst);
        have.insert(pr[lst].ss);
        lst = pr[lst].ff;
    }
    reverse(all(ans));
}

void solve() {
    cin >> n >> m >> s >> t;
    --s, --t;
    for (int i = 0; i < m; ++i) {
        int x, y; cin >> x >> y, --x, --y;
        add_edg(x, y, 1, i);
    }
    int flow = dinic();
    if (flow == 2) {
        cout << "YES\n";
        vector<int> ans;
        get(s, ans);
        for (auto v : ans) {
            cout << v + 1 << " ";
        }
        cout << '\n';
        ans.clear();
        get(s, ans);
        for (auto v : ans) {
            cout << v + 1 << " ";
        }
        cout << '\n';
    } else {
        cout << "NO\n";
    }
}

signed main() {
#ifdef LOCAL
    freopen("TASK.in", "r", stdin);
    freopen("TASK.out", "w", stdout);
#else
    freopen("snails.in", "r", stdin);
    freopen("snails.out", "w", stdout);
#endif // LOCAL
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.precision(20);
    cout << fixed;
    int t = 1;
    for (int i = 0; i < t; ++i)
        solve();
    return 0;
}