#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos((long double)-1.0);
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
template <typename T>
void cmin(T &x, T y) {
  if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
  if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
  if (n < 0) return 0;
  long long res = 1;
  while (n) {
    if (n & 1) res = res * x % mod;
    x = x * x % mod;
    n >>= 1;
  }
  return res;
}
long long sq(long long x) { return x * x; }
double sq(double x) { return x * x; }
long long read() {
  long long res = 0;
  char c = getchar();
  while (!isdigit(c)) c = getchar();
  while (isdigit(c)) {
    res = res * 10 + (c - '0');
    c = getchar();
  }
  return res;
}
struct Matrix {
  static const int MAXN = 505;
  static const int MAXM = 505;
  int n, m;
  long double A[MAXN][MAXM];
  Matrix() { memset(A, 0, sizeof(A)); }
  void show() {
    printf("Matrix n=%d m=%d\n", n, m);
    for (int i = 1; i <= n; ++i) {
      for (int j = 1; j <= m; ++j) printf("%2.2f ", (double)A[i][j]);
      printf("| %2.2f\n", (double)A[i][m + 1]);
    }
  }
  double x[MAXM];
  int pos[MAXM];
  struct Operation {
    int type;
    int x, y;
    long double k;
  } op;
  vector<Operation> vec;
  int GaussJordan1() {
    vec.clear();
    int row = 0;
    for (int col = 1; col <= m && row <= n; ++col) {
      int pivot = row + 1;
      for (int i = pivot + 1; i <= n; ++i) {
        if (abs(A[i][col]) > abs(A[pivot][col])) pivot = i;
      }
      if (abs(A[pivot][col]) <= EPS) {
        pos[col] = -1;
        continue;
      }
      pos[col] = ++row;
      if (pivot != row) {
        op.type = 1;
        op.x = pivot;
        op.y = row;
        op.k = 0;
        vec.push_back(op);
        for (int j = m + 1; j >= col; --j) swap(A[pivot][j], A[row][j]);
      }
      op.type = 2;
      op.x = row;
      op.y = 0;
      op.k = A[row][col];
      vec.push_back(op);
      for (int j = m + 1; j >= col; --j) A[row][j] /= A[row][col];
      for (int i = 1; i <= n; ++i) {
        if (i == row || abs(A[i][col]) <= EPS) continue;
        op.type = 3;
        op.x = i;
        op.y = row;
        op.k = A[i][col];
        vec.push_back(op);
        for (int j = m + 1; j >= col; --j) A[i][j] -= A[row][j] * A[i][col];
      }
    }
    return 1;
  }
  int GaussJordan2(int id) {
    for (int i = 1; i <= n; ++i) A[i][m + 1] = 0;
    A[id][m + 1] = 1;
    for (Operation o : vec) {
      int type = o.type;
      int x = o.x;
      int y = o.y;
      long double k = o.k;
      if (type == 1) {
        swap(A[x][m + 1], A[y][m + 1]);
        continue;
      }
      if (type == 2) {
        A[x][m + 1] /= k;
        continue;
      }
      if (type == 3) {
        A[x][m + 1] -= A[y][m + 1] * k;
        continue;
      }
    }
    for (int j = 1; j <= m; ++j) {
      if (pos[j] == -1) {
        x[j] = 0;
        continue;
      }
      x[j] = A[pos[j]][m + 1];
    }
    return 1;
  }
} mat;
namespace Solver {
void InitOnce() { int t; }
int n, m, a, b;
vector<int> G[23];
int d[23];
double p[23];
double q[23];
void Read() {
  int res = scanf("%d%d%d%d", &n, &m, &a, &b);
  if (res == -1) exit(0);
  for (int i = 1; i <= n; ++i) G[i].clear();
  for (int i = 1; i <= n; ++i) d[i] = 0;
  while (m--) {
    int u, v;
    scanf("%d%d", &u, &v);
    G[u].emplace_back(v);
    G[v].emplace_back(u);
    ++d[u];
    ++d[v];
  }
  for (int i = 1; i <= n; ++i) scanf("%lf", &p[i]);
  for (int i = 1; i <= n; ++i) q[i] = (1.0 - p[i]) / d[i];
}
int x[500];
int y[500];
int id[23][23];
void Solve() {
  int tot = 0;
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
      id[i][j] = ++tot;
      x[tot] = i;
      y[tot] = j;
    }
  }
  int N = n * n;
  mat.n = N;
  mat.m = N;
  memset(mat.A, 0, sizeof(mat.A));
  for (int a = 1; a <= n; ++a) {
    for (int b = 1; b <= n; ++b) {
      if (a == b) {
        mat.A[id[a][b]][id[a][b]] = 1.0;
        continue;
      }
      mat.A[id[a][b]][id[a][b]] = -1.0 + p[a] * p[b];
      for (int i : G[a]) {
        for (int j : G[b]) {
          mat.A[id[a][b]][id[i][j]] = q[a] * q[b];
        }
      }
      for (int i : G[a]) mat.A[id[a][b]][id[i][b]] = q[a] * p[b];
      for (int j : G[b]) mat.A[id[a][b]][id[a][j]] = p[a] * q[b];
    }
  }
  mat.GaussJordan1();
  for (int i = 1; i <= n; ++i) {
    mat.GaussJordan2(id[i][i]);
    printf("%.10f%c", (double)mat.x[id[a][b]], " \n"[i == n]);
  }
}
}  // namespace Solver
int main() {
  Solver::InitOnce();
  while (true) {
    Solver::Read();
    Solver::Solve();
  }
  return 0;
}
