#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
using namespace std;

namespace IO {
  char ibuf[1 << 20], *iS, *iT;
#ifndef LOCAL
#define gh() (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, 1 << 20, stdin), (iS == iT ? EOF : *iS++) : *iS++)
#else
#define gh() getchar()
#endif
  template<typename T = int>
  IL T read () {
    T x = 0;
    bool f = 0;
    char c = gh();
    while (c < '0' || '9' < c) f |= c == '-', c = gh();
    while ('0' <= c && c <= '9') x = (x << 1) + (x << 3) + (c ^ 48), c = gh();
    return f ? ~(x - 1) : x;
  }
}

using IO::read;
using vi = vector<int>;

constexpr int N = 1e3 + 9;
int n, m, A, B, w[N], ord[N];
vi g[N], e[N];

namespace BO {
  int id[N], dfn[N], low[N], dfc, p[N], dcc;

  IL void dfs (int u, int fa) {
    id[dfn[u] = low[u] = ++dfc] = u;
    for (int v : g[u]) {
      if (v ^ fa) {
        if (!dfn[v]) {
          dfs(v, u);
          p[v] = u;
          low[u] = min(low[u], low[v]);
          dcc += low[v] >= dfn[u];
        } else {
          low[u] = min(low[u], dfn[v]);
        }
      }
    }
  }

  int pr[N], nx[N];
  bool sgn[N];

  bool chk () {
    g[A].insert(g[A].begin(), B);
    g[B].insert(g[B].begin(), A);
    dfs(A, 0);
    if (dcc >= 2) {
      return false;
    }
    pr[A] = 0;
    nx[0] = A;
    pr[B] = A;
    nx[A] = B;
    pr[n + 1] = B;
    nx[B] = n + 1;
    L (i, 3, n) {
      int u = id[i];
      int ac = id[low[u]];
      if (!sgn[ac]) {
        int P = pr[p[u]];
        pr[u] = P;
        nx[u] = p[u];
        nx[P] = pr[p[u]] = u;
      } else {
        int S = nx[p[u]];
        nx[u] = S;
        pr[u] = p[u];
        pr[S] = nx[p[u]] = u;
      }
      sgn[p[u]] = !sgn[ac];
    }
    int x = A;
    L (i, 1, n) {
      ord[i] = x;
      x = nx[x];
    }
    g[A].erase(g[A].begin());
    g[B].erase(g[B].begin());
    return true;
  }
}

int rk[N], pr[N];

vi pat;
IL void dfs (int u, int W) {
  pat.eb(u);
  int p = 1e9, q = 0;
  for (int v : e[u]) {
    if (w[v] < p) {
      p = w[v];
      q = v;
    }
  }
  if (p > W) {
    return;
  }
  swap(w[u], w[q]);
  dfs(q, W);
}

int main () {
  cout.tie(0) -> sync_with_stdio(0);
  n = read(), m = read(), A = read(), B = read();
  L (i, 1, n) w[i] = read();
  L (i, 1, m) {
    int u = read(), v = read();
    g[u].eb(v);
    g[v].eb(u);
  }
  if (!BO::chk()) {
    cout << "-1\n";
    return 0;
  }
  L (i, 1, n) rk[ord[i]] = i;
  L (u, 1, n) {
    for (int v : g[u]) {
      if (rk[u] < rk[v]) {
        e[u].eb(v);
        pr[v] = u;
      }
    }
  }
  vector<vi> as;
  R (i, n - 1, 1) {
    int ww = w[A], v = ord[i];
    pat.clear();
    dfs(v, ww);
    swap(ww, w[pat.back()]);
    vi q;
    for (int x = pr[v]; x; x = pr[x]) {
      swap(ww, w[x]);
      q.eb(x);
    }
    reverse(q.begin(), q.end());
    for (int y : pat) {
      q.eb(y);
    }
    as.eb(q);
  }
  cout << as.size() << '\n';
  for (auto q : as) {
    cout << q.size() << ' ';
    for (int v : q) cout << v << ' ';
    cout << '\n';
  }
}
// I love WHQ!