#include <bits/stdc++.h>
using namespace std;
const int MAXN = 22;
const double EPS = 1e-9;
int n, m;
vector<vector<int> > G;
double prob[MAXN + 5];
int A, B;
vector<vector<double> > buildMatrix(int target) {
  vector<vector<double> > mat(n * n, vector<double>(n * n + 1, 0));
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) {
      int x = (i * n + j);
      mat[x][x] = 1;
      if (i == j) {
        mat[x].back() = i == target;
        continue;
      }
      vector<pair<int, double> > p[2];
      p[0].push_back(make_pair(i, prob[i]));
      p[1].push_back(make_pair(j, prob[j]));
      for (int c = 0; c < G[i].size(); c++)
        p[0].push_back(make_pair(G[i][c], (1 - prob[i]) / G[i].size()));
      for (int c = 0; c < G[j].size(); c++)
        p[1].push_back(make_pair(G[j][c], (1 - prob[j]) / G[j].size()));
      for (int c = 0; c < p[0].size(); c++)
        for (int c2 = 0; c2 < p[1].size(); c2++) {
          int y = (p[0][c].first * n + p[1][c2].first);
          mat[x][y] -= p[0][c].second * p[1][c2].second;
        }
    }
  return mat;
}
namespace BlackBox {
namespace rng_58 {
vector<vector<double> > inverse(vector<vector<double> > A) {
  int i, j, k;
  int D = A.size();
  vector<vector<double> > B(D, vector<double>(D));
  for ((i) = 0; (i) < (int)(D); (i)++)
    for ((j) = 0; (j) < (int)(D); (j)++) B[i][j] = ((i == j) ? 1.0 : 0.0);
  for ((i) = 0; (i) < (int)(D); (i)++) {
    int x = i;
    for (j = i; j < D; j++)
      if (((A[j][i]) > 0 ? (A[j][i]) : -(A[j][i])) >
          ((A[x][i]) > 0 ? (A[x][i]) : -(A[x][i])))
        x = j;
    if (x != i) {
      for ((j) = 0; (j) < (int)(D); (j)++) swap(A[i][j], A[x][j]);
      for ((j) = 0; (j) < (int)(D); (j)++) swap(B[i][j], B[x][j]);
    }
    double p = A[i][i];
    for ((j) = 0; (j) < (int)(D); (j)++) {
      A[i][j] /= p;
      B[i][j] /= p;
    }
    for ((j) = 0; (j) < (int)(D); (j)++)
      if (j != i) {
        p = -A[j][i];
        for ((k) = 0; (k) < (int)(D); (k)++) A[j][k] += A[i][k] * p;
        for ((k) = 0; (k) < (int)(D); (k)++) B[j][k] += B[i][k] * p;
      }
  }
  return B;
}
}  // namespace rng_58
}  // namespace BlackBox
vector<double> operator*(const vector<vector<double> >& mat,
                         const vector<double>& vec) {
  vector<double> ret(vec.size());
  for (int i = 0; i < ret.size(); i++) {
    ret[i] = 0;
    for (int j = 0; j < ret.size(); j++) ret[i] += mat[i][j] * vec[j];
  }
  return ret;
}
int main() {
  scanf("%d%d%d%d", &n, &m, &A, &B);
  A--;
  B--;
  int c, c2;
  G.resize(n);
  for (c = 0; c < m; c++) {
    int from, to;
    scanf("%d%d", &from, &to);
    from--;
    to--;
    G[from].push_back(to);
    G[to].push_back(from);
  }
  for (int i = 0; i < n; i++) scanf("%lf", &prob[i]);
  vector<vector<double> > temp = buildMatrix(0);
  vector<vector<double> > mat(n * n, vector<double>(n * n));
  for (c = 0; c < n * n; c++)
    for (c2 = 0; c2 < n * n; c2++) mat[c][c2] = temp[c][c2];
  vector<vector<double> > _mat = BlackBox::rng_58::inverse(mat);
  for (int i = 0; i < n; i++) {
    vector<double> freeterms(n * n, 0);
    freeterms[(i * n + i)] = 1.0;
    vector<double> ret = _mat * freeterms;
    if (i) printf(" ");
    printf("%.10lf", ret[(A * n + B)]);
  }
  printf("\n");
  return 0;
}
