#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 25;
const int maxN = 505;

int n, m, A, B, cnt;
db p[maxn];
struct Edge
{
  int nxt, to;
}e[maxn * maxn * 2];
int head[maxn], ecnt = -1, du[maxn];
 void addEdge(int x, int y)
{
  ++du[x];
  e[++ecnt] = (Edge){head[x], y};
  head[x] = ecnt;
}

 int N(int x, int y) {return (x - 1) * n  + y;}

db f[maxN][maxN], ans[maxN];
 void init()
{
  f[N(A, B)][cnt + 1] = 1;
  for(int i = 1; i <= n; ++i)
    for(int j = 1; j <= n; ++j)
      {
	//if(i == A && j == B) continue;
	int u = N(i, j);
	f[u][u] = 1;
	if(i ^ j) f[u][u] -= p[i] * p[j];
	for(int k = head[j], v; ~k; k = e[k].nxt)
	  if((v = e[k].to) ^ i) f[u][N(i, v)] -= p[i] * (1 - p[v]) / du[v];
	for(int k = head[i], v; ~k; k = e[k].nxt)
	  if((v = e[k].to) ^ j) f[u][N(v, j)] -= p[j] * (1 - p[v]) / du[v];
	for(int k = head[i], v1; ~k; k = e[k].nxt)
	  for(int h = head[j], v2; ~h; h = e[h].nxt)
	    if((v1 = e[k].to) ^ (v2 = e[h].to))
	      f[u][N(v1, v2)] -= (1 - p[v1]) * (1 - p[v2]) / du[v1] / du[v2];
      }
}
 void Gauss()
{
  for(int i = 1; i <= cnt; ++i)
    {
      int pos = i;
      for(int j = i + 1; j <= cnt; ++j)
	if(fabs(f[j][i]) > fabs(f[pos][i])) pos = j;
      if(pos ^ i) swap(f[pos], f[i]);
      if(fabs(f[i][i]) < eps) continue;
      db tp = f[i][i];
      for(int j = i; j <= cnt + 1; ++j) f[i][j] /= tp;
      for(int j = i + 1; j <= cnt; ++j)
	{
	  db tp = f[j][i];
	  for(int k = i; k <= cnt + 1; ++k) f[j][k] -= tp * f[i][k];
	}
    }
  for(int i = cnt; i; --i)
    {
      ans[i] = f[i][cnt + 1];
      for(int j = i - 1; j; --j) f[j][cnt + 1] -= f[j][i] * ans[i];
    }
}

int main()
{
  //MYFILE();
  memset(head,-1,sizeof(head));
  scanf("%d%d%d%d",&n,&m,&A,&B);
  cnt = n * n;
  for(int i = 1; i <= m; ++i)
    {
      int x,y;
      scanf("%d%d",&x,&y);
      addEdge(x, y), addEdge(y, x);
    }
  for(int i = 1; i <= n; ++i) scanf("%lf", &p[i]);
  init(), Gauss();
  for(int i = 1; i <= n; ++i) printf("%.8lf\n", ans[N(i, i)]);
  return 0;
}//hello


/**************************************************************
    Problem: ????
    User: Big_Red_Dates
    Language: GNU_C++11
    Result: Accepted
    Time:0 ms
    Memory:0 kb
    length:0 kb
    score: inf
****************************************************************/
//CLOCKS_PER_SEC
using namespace std;
#include<bitset>
#include<deque>
#include<stdint.h>
#include<set>
#include<stack>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<ctime>
#include<map>
#define sqr(x) (x)*(x)
//#define sort stable_sort
#define ll long long
#define mk make_pair
#define pb push_back
#define in insert
#define mtr(x,y,z) mk(mk(x,y),z)
#define fi first
#define se second
#define lch(x) ((x)<<1)
#define rch(x) (((x)<<1)|1)
#define all(x) (x).begin(),(x).end()
#define titose CLOCKS_PER_SEC
#define fpi(x) freopen(x,"r",stdin);
#define fpo(x) freopen(x,"w",stdout);
#define fprio fpi("in.txt");fpo("out.txt");
#define fast ios_base::sync_with_stdio(false);
inline void read(int &x){int v=0,f=1;char c=getchar();while (!isdigit(c)&&c!='-') c=getchar();if (c=='-') f=-1; else v=(c&15);while (isdigit(c=getchar())) v=(v<<1)+(v<<3)+(c&15);x=v*f;}
inline void read(ll &x){ll v=0ll,f=1ll;char c=getchar();while (!isdigit(c)&&c!='-') c=getchar();if (c=='-') f=-1; else v=(c&15);while (isdigit(c=getchar())) v=(v<<1)+(v<<3)+(c&15);x=v*f;}
inline void readc(char &x){char c;while ((c=getchar())==' ');x=c;}
inline void writes(string s){puts(s.c_str());}
inline void writeln(){writes("");}
inline void writei(int x){if (x<0){putchar('-');x=abs(x);}if (!x) putchar('0');char a[25];int top=0;while (x){a[++top]=(x%10)+'0';x/=10;}while (top){putchar(a[top]);top--;}}
inline void writell(ll x){if (x<0){putchar('-');x=abs(x);}if (!x) putchar('0');char a[25];int top=0;while (x){a[++top]=(x%10)+'0';x/=10;}while (top){putchar(a[top]);top--;}}
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vl vector<ll>
#define si set<int>
#define sl set<ll>
#define mii map<int,int>
#define mll map<ll,ll>
#define msi map<string,int>
#define msl map<string,ll>
#define piii pair<int,pii >
#define piipi pair<pii,int>
#define plll pair<ll,pll >
#define pllpl pair<pll,ll>
#define pqi priority_queue<int>
#define pql priority_queue<ll>
#define npqi priority_queue<int,vector<int>,greater<int> >
#define npql priority_queue<ll,vector<ll>,greater<ll> >
#define forup(i,a,b) for ((i)=(a);(i)<=(b);(i)++)
#define fordo(i,a,b) for ((i)=(a);(i)>=(b);(i)--)
#define rep(i,x) forup ((i),1,(x))
#define repd(i,x) fordo ((i),(x),1)
#define itr iterator
#define fe(itcalc,c) for(__typeof((c).begin()) itcalc=(c).begin();itcalc!=(c).end();itcalc++)
#define NO {cout<<"NO";return 0;}
#define YES {cout<<"YES";return 0;}
#define y0 y000000000000000000000000000
#define y1 y111111111111111111111111111
#define j0 j000000000000000000000000000
#define j1 j111111111111111111111111111
#define cl0(a) memset((a),(0),(sizeof((a))))
#define clz(a) memset((a),(0x16),(sizeof((a))))
#define clf(a) memset((a),(-(0x16)),(sizeof((a))))
#define inf 0x3bbbbbbb
#define lnf 0x1bbbbbbbbbbbbbbbll
#define sqrt divi
#define p2(i) (1ll<<(i))
#define readi read
#define readll read
/*************************************************/
double a[500][500],p[25],g[25][25],f[500];
int n,m,sa,b,i,j,k,l,deg[25],co;
int id(int x,int y)
{
	return (x-1)*n+y;
}
int main()
{
	read(n);read(m);read(sa);read(b);
	co=n*n+1;
	a[id(sa,b)][co]=-1;
	rep(i,m){
		int x,y;
		read(x);read(y);
		deg[x]++;deg[y]++;
		g[x][y]++;g[y][x]++;
	}
	rep(i,n){
		scanf("%lf",&p[i]);
		g[i][i]=p[i];
		rep(j,n)if(i!=j){
			g[i][j]*=(1-p[i])/deg[i];
		}
	}
	rep(i,n){
		rep(j,n){
			a[id(i,j)][id(i,j)]=-1;
			rep(k,n){
				rep(l,n){
					if(k!=l){
						a[id(i,j)][id(k,l)]+=g[k][i]*g[l][j];
					}
				}
			}
		}
	}
	rep(i,n*n){
		forup(j,i+1,n*n){
			double t=a[j][i]/a[i][i];
			forup(k,i,n*n+1){
				a[j][k]=a[j][k]-a[i][k]*t;
			}
		}
	}
	repd(i,n*n){
		f[i]=a[i][co]/a[i][i];
		rep(j,i-1){
			a[j][co]-=a[j][i]*f[i];
		}
	}
	rep(i,n){
		printf("%.10f ",f[id(i,i)]);
	}
	return 0;
}


#include <cstdio>
#include <iostream>
using namespace std;
#define db double
const int M = 505;
int read()
{
    int num=0,flag=1;char c;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9')num=(num<<3)+(num<<1)+(c^48),c=getchar();
    return num*flag;
}
int n,m,k,A,B,g[M][M],d[M];db a[M][M],p[M];
struct edge
{
	int v,next;
}e[2*M];
int id(int x,int y)
{
	return (x-1)*n+y;
}
void gauss(int n)
{
	for(int i=1;i<=n;i++)
	{
		int Max=i;
		for(int j=i+1;j<=n;j++)
			if(a[Max][i]<a[j][i])
				Max=j;
		swap(a[Max],a[i]);
		if(a[i][i]==0) return ;
		for(int j=1;j<=n;j++)
		{
			if(i==j || a[j][i]==0) continue;
			db t=a[j][i]/a[i][i];
			for(int k=i;k<=n+1;k++)
				a[j][k]-=a[i][k]*t;
		}
	}
}
signed main()
{
	n=read();m=read();A=read();B=read();k=n*n;
	for(int i=1;i<=m;i++)
	{
		int u=read(),v=read();
		g[u][v]=g[v][u]=1;
		d[u]++;d[v]++;
	}
	for(int i=1;i<=n;i++)
		scanf("%lf",&p[i]);
	a[id(A,B)][k+1]=1;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			if(i!=j)
				a[id(i,j)][id(i,j)]=1-p[i]*p[j];
			else
				a[id(i,j)][id(i,j)]=1;
			for(int k=1;k<=n;k++)
				if(g[j][k] && i!=k)
					a[id(i,j)][id(i,k)]-=(1-p[k])/d[k]*p[i];
			for(int k=1;k<=n;k++)
				if(g[i][k] && j!=k)
					a[id(i,j)][id(k,j)]-=(1-p[k])/d[k]*p[j];
			for(int x=1;x<=n;x++)
				for(int y=1;y<=n;y++)
					if(g[i][x] && g[j][y] && x!=y)
						a[id(i,j)][id(x,y)]-=(1-p[x])*(1-p[y])/d[x]/d[y];
		}
	gauss(k);
	//printf("%.10lf\n",a[id(A,B)][k+1]/a[id(A,B)][id(A,B)]);
	for(int i=1;i<=n;i++)
		printf("%.10lf ",a[id(i,i)][k+1]/a[id(i,i)][id(i,i)]);
}


#include<bits/stdc++.h>
#define reg register
typedef long long ll;
using namespace std;
const int MN=23;
const int MM=465;
int to[MM],nxt[MM],h[MN],cnt;
inline void ins(int s,int t){
	to[++cnt]=t;nxt[cnt]=h[s];h[s]=cnt;
	to[++cnt]=s;nxt[cnt]=h[t];h[t]=cnt;
}
int n,m,idx,lim,S,T,deg[MN],id[MN][MN];
double p[MN],q[MN],A[MN][MN][MN][MN],P[485][485];
int main(){
	scanf("%d%d%d%d",&n,&m,&S,&T);
    if(S==T){
        for(reg int i=1;i<=n;i++)printf("%d ",i==S);
        return 0;
    }
	for(reg int i=1,s,t;i<=m;i++){
		scanf("%d%d",&s,&t);
		deg[s]++;deg[t]++;ins(s,t);
	}
	for(reg int i=1;i<=n;i++)
		scanf("%lf",p+i),q[i]=(1.-p[i])/deg[i];
	for(reg int i=1;i<=n;i++)
		for(reg int j=1;j<=n;j++){
			if(i==j)continue;
			A[i][j][i][j]=p[i]*p[j];
			for(reg int x=h[i];x;x=nxt[x])
				A[i][j][to[x]][j]=q[i]*p[j];
			for(reg int x=h[j];x;x=nxt[x])
				A[i][j][i][to[x]]=p[i]*q[j];
			for(reg int x=h[i];x;x=nxt[x])
				for(reg int y=h[j];y;y=nxt[y])
					A[i][j][to[x]][to[y]]=q[i]*q[j];
		}
	for(reg int i=1;i<=n;i++)
		for(reg int j=1;j<=n;j++)
			if(i!=j)id[i][j]=++idx;
	lim=idx;
	for(reg int i=1;i<=n;i++)id[i][i]=++idx;
	for(reg int i=1;i<=n;i++)
		for(reg int j=1;j<=n;j++){
			if(i==j)continue;
			for(reg int k=1;k<=n;k++)
				for(reg int l=1;l<=n;l++)
					P[id[i][j]][id[k][l]]=A[i][j][k][l];
			P[id[i][j]][id[i][j]]-=1.;
		}
	for(reg int i=1;i<=lim;i++){
		reg int pos=i;
		for(reg int j=i+1;j<=lim;j++)
			if(fabs(P[j][i])>fabs(P[pos][i]))pos=j;
		if(pos!=i)swap(P[pos],P[i]);
		for(reg int j=i+1;j<=idx;j++)P[i][j]/=P[i][i];
		P[i][i]=1;
		for(reg int j=1;j<=lim;j++){
			if(i==j)continue;
			for(reg int k=i+1;k<=idx;k++)
				P[j][k]-=P[j][i]*P[i][k];
			P[j][i]=0;
		}
	}
	for(reg int i=1;i<=n;i++)
		printf("%lf ",-P[id[S][T]][lim+i]);
	return 0;
}


#include<bits/stdc++.h>
#define reg register
typedef long long ll;
using namespace std;
const int MN=23;
const int MM=465;
int to[MM],nxt[MM],h[MN],cnt;
inline void ins(int s,int t){
	to[++cnt]=t;nxt[cnt]=h[s];h[s]=cnt;
	to[++cnt]=s;nxt[cnt]=h[t];h[t]=cnt;
}
int n,m,idx,lim,S,T,deg[MN],id[MN][MN];
double p[MN],q[MN],A[MN][MN][MN][MN],P[485][485];
int main(){
	scanf("%d%d%d%d",&n,&m,&S,&T);
	for(reg int i=1,s,t;i<=m;i++){
		scanf("%d%d",&s,&t);
		deg[s]++;deg[t]++;ins(s,t);
	}
	for(reg int i=1;i<=n;i++)
		scanf("%lf",p+i),q[i]=(1.-p[i])/deg[i];
	for(reg int i=1;i<=n;i++)
		for(reg int j=1;j<=n;j++){
			if(i==j)continue;
			A[i][j][i][j]=p[i]*p[j];
			for(reg int x=h[i];x;x=nxt[x])
				A[i][j][to[x]][j]=q[i]*p[j];
			for(reg int x=h[j];x;x=nxt[x])
				A[i][j][i][to[x]]=p[i]*q[j];
			for(reg int x=h[i];x;x=nxt[x])
				for(reg int y=h[j];y;y=nxt[y])
					A[i][j][to[x]][to[y]]=q[i]*q[j];
		}
	for(reg int i=1;i<=n;i++)
		for(reg int j=1;j<=n;j++)
			if(i!=j)id[i][j]=++idx;
	lim=idx;
	for(reg int i=1;i<=n;i++)id[i][i]=++idx;
	for(reg int i=1;i<=n;i++)
		for(reg int j=1;j<=n;j++){
			if(i==j)continue;
			for(reg int k=1;k<=n;k++)
				for(reg int l=1;l<=n;l++)
					P[id[i][j]][id[k][l]]=A[i][j][k][l];
			P[id[i][j]][id[i][j]]-=1.;
		}
	for(reg int i=1;i<=lim;i++){
		reg int pos=i;
		for(reg int j=i+1;j<=lim;j++)
			if(fabs(P[j][i])>fabs(P[pos][i]))pos=j;
		if(pos!=i)swap(P[pos],P[i]);
		for(reg int j=i+1;j<=idx;j++)P[i][j]/=P[i][i];
		P[i][i]=1;
		for(reg int j=1;j<=lim;j++){
			if(i==j)continue;
			for(reg int k=i+1;k<=idx;k++)
				P[j][k]-=P[j][i]*P[i][k];
			P[j][i]=0;
		}
	}
	for(reg int i=1;i<=n;i++)
		printf("%lf ",-P[id[S][T]][lim+i]);
	return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-9
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

const int N = 25;
int n,m,a,b;
double p[N], pr[N];
vector<int> g[N];
double dp[15001][N][N];
int main()
{
    cin>>n >> m >> a >> b;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    for(int i = 1;i <= n; i ++) cin >> pr[i];
    if(a == b) {
        p[a] =1;
        for(int i= 1;i <= n;i ++ ) printf("%.9lf ",p[i]);
        return 0;
    }

    dp[0][a][b] = 1;
    for(int it = 0;it < 15000; it ++ ) {
        for(int i =1;i <= n;i ++) {
            for(int j = 1; j <= n;j ++ ) {
                if(i == j) continue;
                if(dp[it][i][j] < EPS) continue;
                for(auto x: g[i] ) {
                    for(auto y: g[j]) {
                        dp[it + 1][x][y] += dp[it][i][j] * (1 - pr[i]) / g[i].size() * (1 - pr[j] )/ g[j].size();

                    }
                }
                for(auto y : g[j]) dp[it + 1][i][y] += dp[it][i][j] * pr[i] * (1 - pr[j])/g[j].size();
                for(auto x : g[i]) dp[it + 1][x][j] += dp[it][i][j] * (1 - pr[i] )/ g[i].size() *pr [j];
                dp[it + 1][i][j] += dp[it][i][j] * pr[i] * pr[j];
            }
        }
        for(int i = 1;i <= n;i ++) p[i] += dp[it + 1][i][i];
    }
    for(int i = 1;i <= n;i ++)  printf("%.9lf ",p[i]);
    return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-14
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

struct Gauss{
    /*          1  1 |  3  5
                1 -1 |  1  6
                {x+y=3}{x+y=5}
                {x-y=1}{x-y=6}
    */
    void show(vector<vector<double> > a, vector <vector< double> > b)
    {
        for(int i= 0;i< a.size();i ++) {
            for(int j= 0;j < a[i].size(); j ++) printf("%5.2lf ",a[i][j]);
            printf("| ");
            for(int j = 0; j < b[i].size(); j ++) printf("%5.2lf ",b[i][j]);
            printf("\n");
        }
    }
    int gauss(vector< vector< double > > &a , vector< vector<double > > &b)
    {
        // AX = B;
        // Here n -> # of equations, m = number of column in A, p = # column in B
        // The function returns the rank of the matrix
        int n = a.size(), m= a[0].size() , p = b[0].size();
        int r = 0;

        for(int c = 0; c < m  && r < n ; c ++ ) {
            int j = r;
//            for(int i = r+1; i < n; i ++ ) {
//                if(fabs(a[i][c]) > fabs(a[j][c])) j= i;
//            }
            if(fabs(a[j][c]) < EPS) continue;
            swap(a[j],a[r]);
            double s = 1./a[r][c];

            for(int i = 0; i < m ; i ++ ) a[r][i] *= s;
            for(int i = 0; i < p ; i ++ ) b[r][i] *= s;
            for(int i=0;i < n ;i ++) if(i!=r) {
                double t = a[i][c];
                for(int j = 0; j < m ; j ++ ) a[i][j] -= t * a[r][j];
                for(int j = 0; j < p ; j ++ ) b[i][j] -= t * b[r][j];
            }
            r++;
        }
        return r;
    }
}g;

const int N = 22;
int gv[N][N];
int deg[N];
int n,m,a,b;
double prob[N];

int main()
{
    cin >> n >> m >> a >> b;
    a--,b--;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        u--;v--;
        gv[u][v] = gv[v][u] = 1;
        deg[u]++;
        deg[v]++;
    }
    for(int i = 0;i < n; i++) cin >> prob[i];

    vector< vector< double> > A( n * n , vector< double> (n * n, 0));
    vector< vector< double> > B( n * n , vector< double> (n , 0));
    for(int i =0; i< n;i ++) {
        for(int j = 0; j < n; j ++ ) {
            if(i == j) {
                A[i*n+j][i*n+j] = 1;
                B[i*n+j][i] = 1;
            }
            else {
                A[i*n+j][i*n+j] = 1;
                A[i*n+j][i*n+j] -= prob[i] * prob[j];
                for(int k = 0; k < n; k ++) if(gv[i][k]) A[i*n+j][k*n+j] -= (1- prob[i]) / deg[i] * prob[j];
                for(int k = 0; k < n; k ++) if(gv[j][k]) A[i*n+j][i*n+k] -= prob[i] * (1 - prob[j]) / deg[j];

                for(int k = 0; k < n; k ++ ){
                    for(int l = 0; l < n; l ++ ) {
                        if(gv[i][k] && gv[j][l] && k != i && l != j ) {
                            A[i*n +j][k*n+l] -= (1 - prob[i])/deg[i] * (1 -prob[j])/ deg[j];
                        }
                    }
                }
            }
        }
    }
    g.gauss(A,B);

    for(int i = 0;i <n; i ++)  {
        printf("%.10lf ",B[a*n+b][i]);
    }
    return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-14
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

struct Gauss{
    /*          1  1 |  3  5
                1 -1 |  1  6
                {x+y=3}{x+y=5}
                {x-y=1}{x-y=6}
    */
    void show(vector<vector<double> > a, vector <vector< double> > b)
    {
        for(int i= 0;i< a.size();i ++) {
            for(int j= 0;j < a[i].size(); j ++) printf("%5.2lf ",a[i][j]);
            printf("| ");
            for(int j = 0; j < b[i].size(); j ++) printf("%5.2lf ",b[i][j]);
            printf("\n");
        }
    }
    int gauss(vector< vector< double > > &a , vector< vector<double > > &b)
    {
        // AX = B;
        // Here n -> # of equations, m = number of column in A, p = # column in B
        // The function returns the rank of the matrix
        int n = a.size(), m= a[0].size() , p = b[0].size();
        int r = 0;

        for(int c = 0; c < m  && r < n ; c ++ ) {
            int j = r;
            for(int i = r+1; i < n; i ++ ) {
                if(fabs(a[i][c]) > fabs(a[j][c])) j= i;
            }
            if(fabs(a[j][c]) < EPS) continue;
            if(j!=r)swap(a[j],a[r]), swap(b[j],b[r]);
            double s = 1./a[r][c];

            for(int i = 0; i < m ; i ++ ) a[r][i] *= s;
            for(int i = 0; i < p ; i ++ ) b[r][i] *= s;
            for(int i=0;i < n ;i ++) if(i!=r) {
                double t = a[i][c];
                for(int j = 0; j < m ; j ++ ) a[i][j] -= t * a[r][j];
                for(int j = 0; j < p ; j ++ ) b[i][j] -= t * b[r][j];
            }
            r++;
        }
        return r;
    }
}g;

const int N = 22;
int gv[N][N];
int deg[N];
int n,m,a,b;
double prob[N];

int main()
{
    cin >> n >> m >> a >> b;
    a--,b--;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        u--;v--;
        gv[u][v] = gv[v][u] = 1;
        deg[u]++;
        deg[v]++;
    }
    for(int i = 0;i < n; i++) cin >> prob[i];

    vector< vector< double> > A( n * n , vector< double> (n * n, 0));
    vector< vector< double> > B( n * n , vector< double> (n , 0));
    for(int i =0; i< n;i ++) {
        for(int j = 0; j < n; j ++ ) {
            if(i == j) {
                A[i*n+j][i*n+j] = 1;
                B[i*n+j][i] = 1;
            }
            else {
                A[i*n+j][i*n+j] = 1;
                A[i*n+j][i*n+j] -= prob[i] * prob[j];
                for(int k = 0; k < n; k ++) if(gv[i][k]) A[i*n+j][k*n+j] -= (1- prob[i]) / deg[i] * prob[j];
                for(int k = 0; k < n; k ++) if(gv[j][k]) A[i*n+j][i*n+k] -= prob[i] * (1 - prob[j]) / deg[j];

                for(int k = 0; k < n; k ++ ){
                    for(int l = 0; l < n; l ++ ) {
                        if(gv[i][k] && gv[j][l] && k != i && l != j ) {
                            A[i*n +j][k*n+l] -= (1 - prob[i])/deg[i] * (1 -prob[j])/ deg[j];
                        }
                    }
                }
            }
        }
    }
    g.gauss(A,B);

    for(int i = 0;i <n; i ++)  {
        printf("%.10lf ",B[a*n+b][i]);
    }
    return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-9
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

const int N = 25;
int n,m,a,b;
double p[N], pr[N];
vector<int> g[N];
double dp[5001][N][N];
int main()
{
    cin>>n >> m >> a >> b;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    for(int i = 1;i <= n; i ++) cin >> pr[i];
    if(a == b) {
        p[a] =1;
        for(int i= 1;i <= n;i ++ ) printf("%.9lf ",p[i]);
        return 0;
    }

    dp[0][a][b] = 1;
    for(int it = 0;it < 2000; it ++ ) {
        for(int i =1;i <= n;i ++) {
            for(int j = 1; j <= n;j ++ ) {
                if(i == j) continue;
                for(auto x: g[i] ) {
                    for(auto y: g[j]) {
                        dp[it + 1][x][y] += dp[it][i][j] * (1 - pr[i]) / g[i].size() * (1 - pr[j] )/ g[j].size();

                    }
                }
                for(auto y : g[j]) dp[it + 1][i][y] += dp[it][i][j] * pr[i] * (1 - pr[j])/g[j].size();
                for(auto x : g[i]) dp[it + 1][x][j] += dp[it][i][j] * (1 - pr[i] )/ g[i].size() *pr [j];
                dp[it + 1][i][j] += dp[it][i][j] * pr[i] * pr[j];
            }
        }
        for(int i = 1;i <= n;i ++) p[i] += dp[it + 1][i][i];
    }
    for(int i = 1;i <= n;i ++)  printf("%.9lf ",p[i]);
    return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-9
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

const int N = 25;
int n,m,a,b;
double p[N], pr[N];
vector<int> g[N];
double dp[25001][N][N];
int main()
{
    cin>>n >> m >> a >> b;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    for(int i = 1;i <= n; i ++) cin >> pr[i];
    if(a == b) {
        p[a] =1;
        for(int i= 1;i <= n;i ++ ) printf("%.9lf ",p[i]);
        return 0;
    }

    dp[0][a][b] = 1;
    for(int it = 0;it < 15000; it ++ ) {
        for(int i =1;i <= n;i ++) {
            for(int j = 1; j <= n;j ++ ) {
                if(i == j) continue;

                dp[it + 1][i][j] += dp[it][i][j] * pr[i] * pr[j];
                for(auto y : g[j]) dp[it + 1][i][y] += dp[it][i][j] * pr[i] * (1 - pr[j])/g[j].size();
                for(auto x : g[i]) dp[it + 1][x][j] += dp[it][i][j] * (1 - pr[i] )/ g[i].size() *pr [j];

                if(dp[it][i][j] < EPS) continue;

                for(auto x: g[i] ) {
                    for(auto y: g[j]) {
                        dp[it + 1][x][y] += dp[it][i][j] * (1 - pr[i]) / g[i].size() * (1 - pr[j] )/ g[j].size();

                    }
                }

            }
        }
        for(int i = 1;i <= n;i ++) p[i] += dp[it + 1][i][i];
    }
    for(int i = 1;i <= n;i ++)  printf("%.9lf ",p[i]);
    return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-9
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

const int N = 25;
int n,m,a,b;
double p[N], pr[N];
vector<int> g[N];
double dp[5001][N][N];
int main()
{
    cin>>n >> m >> a >> b;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    for(int i = 1;i <= n; i ++) cin >> pr[i];
    if(a == b) {
        p[a] =1;
        for(int i= 1;i <= n;i ++ ) printf("%.9lf ",p[i]);
        return 0;
    }

    dp[0][a][b] = 1;
    for(int it = 0;it < 5000; it ++ ) {
        for(int i =1;i <= n;i ++) {
            for(int j = 1; j <= n;j ++ ) {
                if(i == j) continue;
                for(auto x: g[i] ) {
                    for(auto y: g[j]) {
                        dp[it + 1][x][y] += dp[it][i][j] * (1 - pr[i]) / g[i].size() * (1 - pr[j] )/ g[j].size();

                    }
                }
                for(auto y : g[j]) dp[it + 1][i][y] += dp[it][i][j] * pr[i] * (1 - pr[j])/g[j].size();
                for(auto x : g[i]) dp[it + 1][x][j] += dp[it][i][j] * (1 - pr[i] )/ g[i].size() *pr [j];
                dp[it + 1][i][j] += dp[it][i][j] * pr[i] * pr[j];
            }
        }
        for(int i = 1;i <= n;i ++) p[i] += dp[it + 1][i][i];
    }
    for(int i = 1;i <= n;i ++)  printf("%.9lf ",p[i]);
    return 0;
}


/*
 * DATE : 2017-07-07
 * Algo :
*/
#include<bits/stdc++.h>
using namespace std;
/*------- Constants---- */

#define LL                      long long
#define Ulong                   unsigned long long
#define FOR(I,A,B)              for(long long i=0; i < n ; i++ )
#define REP(i,n)                for(long long i=0; i < n ; i++ )
#define mp                      make_pair
#define pb                      push_back
#define all(x)                  (x).begin(),(x).end()
#define PI                      acos(-1.0)
#define EPS                     1e-9
#define F                       first
#define S                       second
#define di(x)                   int x; input(x)
#define in(x)                   input(x)
#define in2(x,y)                in(x),in(y)
#define in3(x,y,z)              in(x),in2(y,z)
#define lc                      ((n)<<1)
#define rc                      ((n)<<1|1)
#define db(x)                   cout << #x << " -> " << x << endl;
#define ms(ara_name,value)      memset(ara_name,value,sizeof(ara_name))
#define IO                      ios_base::sync_with_stdio(0);cin.tie(0)
#define READ                    freopen("in.txt","r",stdin)
#define WRITE                   freopen("out.txt","w",stdout)
template<class T> inline void input(T &x) {
    register char c = getchar();x = 0;
    int neg = 0;
    for(; ((c<48 || c>57) && c != '-'); c = getchar());
    if(c=='-'){neg = 1;c = getchar();}
    for(; c>47 && c<58 ; c = getchar()){x = (x<<1) + (x<<3) + c - 48;}
    if(neg) x = -x;
}
inline long long bigmod(long long p,long long e,long long M){
    long long ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

/***************************** END OF TEMPLATE *******************************/

const int N = 25;
int n,m,a,b;
double p[N], pr[N];
vector<int> g[N];
double dp[250][N][N];
int main()
{
    cin>>n >> m >> a >> b;
    for(int i = 1;i <= m; i ++ ) {
        int u,v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    for(int i = 1;i <= n; i ++) cin >> pr[i];
    if(a == b) {
        p[a] =1;
        for(int i= 1;i <= n;i ++ ) printf("%.9lf ",p[i]);
        return 0;
    }

    dp[0][a][b] = 1;
    for(int it = 0;it <= 200; it ++ ) {
        for(int i =1;i <= n;i ++) {
            for(int j = 1; j <= n;j ++ ) {
                if(i == j) continue;
                for(auto x: g[i] ) {
                    for(auto y: g[j]) {
                        dp[it + 1][x][y] += dp[it][i][j] * (1 - pr[i]) / g[i].size() * (1 - pr[j] )/ g[j].size();

                    }
                }
                for(auto y : g[j]) dp[it + 1][i][y] += dp[it][i][j] * pr[i] * (1 - pr[j])/g[j].size();
                for(auto x : g[i]) dp[it + 1][x][j] += dp[it][i][j] * (1 - pr[i] )/ g[i].size() *pr [j];
                dp[it + 1][i][j] += dp[it][i][j] * pr[i] * pr[j];
            }
        }
        for(int i = 1;i <= n;i ++) p[i] += dp[it + 1][i][i];
    }
    for(int i = 1;i <= n;i ++)  printf("%.9lf ",p[i]);
    return 0;
}


#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int N=30;
const double eps=1e-14;
typedef int LL;

double A[N*N][N*N],B[N*N][N],X[N*N][N];
int mp[N][N],tot;
double p[N];
int du[N];
vector<int> vv[N];
#define pb push_back

void getA(int n){
    tot=0;
    for(int i=0;i<n;i++){
        for(int j=i;j<n;j++){
            mp[j][i]=mp[i][j]=tot++;
        }
    }
    for(int i=0;i<n;i++){
        A[mp[i][i]][mp[i][i]]=1;
        for(int j=i+1;j<n;j++){
            int s=mp[i][j];
            A[s][s]+=1-p[i]*p[j];
            for(int i1=0;i1<vv[i].size();i1++){
                int ii=vv[i][i1];
                int t=mp[ii][j];
                A[s][t]-=(1-p[i])*p[j]/du[i];
            }
            for(int i1=0;i1<vv[j].size();i1++){
                int jj=vv[j][i1];
                int t=mp[i][jj];
                A[s][t]-=p[i]*(1-p[j])/du[j];
            }
            for(int i1=0;i1<vv[i].size();i1++){
                for(int i2=0;i2<vv[j].size();i2++){
                    int u=vv[i][i1],v=vv[j][i2];
                    int t=mp[u][v];
                    A[s][t]-=(1-p[i])*(1-p[j])/du[i]/du[j];
                }
            }
        }
    }
}
void getB(int n){
    memset(B,0,sizeof(B));
    for(int i=0;i<n;i++){
        B[mp[i][i]][i]=1;
    }
}

void gauss(int n,int m){
    for(int i=0;i<n;i++){
        double tmp=fabs(A[i][i]);
        int id=i;
        for(int j=i;j<n;j++){
            if(fabs(A[j][i])>tmp){
                tmp=fabs(A[j][i]),
                id=j;
            }
        }
        //printf("%d %lf\n",id,tmp);
        for(int j=0;j<n;j++)swap(A[i][j],A[id][j]);
        for(int j=0;j<m;j++)swap(B[i][j],B[id][j]);
        for(int j=i+1;j<n;j++)if(fabs(A[j][i])>eps){
            tmp=A[j][i]/A[i][i];
            for(int k=i;k<n;k++){
                A[j][k]-=A[i][k]*tmp;
            }
            for(int k=0;k<m;k++){
                B[j][k]-=B[i][k]*tmp;
            }
        }
    }
    for(int i=0;i<m;i++){
        for(int j=n-1;j>=0;j--){
            X[j][i]=B[j][i];
            for(int k=n-1;k>j;k--){
                X[j][i]-=A[j][k]*X[k][i];
            }
            X[j][i]/=A[j][j];
        }
    }
}

int main(){
#ifdef DouBi
freopen("in.cpp","r",stdin);
#endif // gh546
    int n,m,s,t;
    while(scanf("%d%d%d%d",&n,&m,&s,&t)!=EOF){
        for(int i=0;i<n;i++)vv[i].clear();
        s--;t--;
        memset(du,0,sizeof(du));
        for(int i=0;i<m;i++){
            int a,b;scanf("%d%d",&a,&b);a--;b--;
            du[a]++;du[b]++;
            vv[a].pb(b);
            vv[b].pb(a);
        }
        for(int i=0;i<n;i++)scanf("%lf",&p[i]);
        memset(A,0,sizeof(A));
        getA(n);
//        for(int i=0;i<tot;i++){
//            for(int j=0;j<tot;j++){
//                printf("%lf ",A[i][j]);
//            }printf("\n");
//        }
        getB(n);
        gauss(tot,n);
        for(int i=0;i<n;i++){
            printf("%.10lf%c",X[mp[s][t]][i],i==n-1?'\n':' ');
        }
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int N = 23;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const double eps = 1e-9;

struct edge
{
	int to , nxt;
} e[N * N * 2];

int n , m , A , B , tot;
int deg[N] , head[N];
double a[N * N][N * N] , b[N * N] , p[N * N];

template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }
template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void read(T &x)
{
   T f = 1; x = 0;
   char c = getchar();
   for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
   for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
   x *= f;
}
inline int id(int x , int y)
{
	return (x - 1) * n + y;
}
inline void addedge(int u , int v)
{
	++tot;
	e[tot] = (edge){v , head[u]};
	head[u] = tot;
}

int main()
{

	scanf("%d%d%d%d" , &n , &m , &A , &B);
	for (int i = 1; i <= m; i++)
	{
		int u , v;
		scanf("%d%d" , &u , &v);
		addedge(u , v);
		addedge(v , u);
		++deg[u]; ++deg[v];
	}
	for (int i = 1; i <= n; i++) scanf("%lf" , &p[i]);
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			a[id(i , j)][id(i , j)]--;
			if (i != j) a[id(i , j)][id(i , j)] += p[i] * p[j];
			for (int k = head[i]; k; k = e[k].nxt)
				if (e[k].to != j) a[id(i , j)][id(e[k].to , j)] += 1.0 * (1.0 * (1 - p[e[k].to]) / deg[e[k].to]) * p[j];
			for (int k = head[j]; k; k = e[k].nxt)
				if (i != e[k].to) a[id(i , j)][id(i , e[k].to)] += 1.0 *  p[i] * (1.0 * (1 - p[e[k].to]) / deg[e[k].to]);
			for (int k = head[i]; k; k = e[k].nxt)
			{
				for (int l = head[j]; l; l = e[l].nxt)
				{
					if (e[k].to != e[l].to)
						a[id(i , j)][id(e[k].to , e[l].to)] += 1.0 * (1.0 * (1 - p[e[k].to]) / deg[e[k].to]) * (1.0 * (1 - p[e[l].to]) / deg[e[l].to]);
				}
			}
		}
	}
	b[id(A , B)] = -1;
	for (int i = 1; i <= n * n; i++)
	{
		for (int j = i; j <= n * n; j++)
		{
			if(fabs(a[j][i]) > eps)
			{
				for (int k = 1; k <= n * n; k++) swap(a[i][k] , a[j][k]);
				swap(b[i] , b[j]);
			}
		}
		for (int j = 1; j <= n * n; j++)
		{
			if (i == j) continue;
			double rate = a[j][i] / a[i][i];
			for (int k = i; k <= n * n; k++) a[j][k] -= a[i][k] * rate;
			b[j] -= b[i] * rate;
		}
	}
	for (int i = 1; i <= n; i++) printf("%.10lf " , 1.0 * b[id(i , i)] / a[id(i , i)][id(i , i)]);
	printf("\n");

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int N = 30;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const double eps = 1e-9;

struct edge
{
	int to , nxt;
} e[N * N * 2];

int n , m , A , B , tot;
int head[N * N];
double deg[N * N] , a[N * N][N * N] , b[N * N] , p[N * N] , ans[N * N];

template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }
template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void read(T &x)
{
   T f = 1; x = 0;
   char c = getchar();
   for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
   for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
   x *= f;
}
inline int id(int x , int y)
{
	return (x - 1) * n + y;
}
inline void addedge(int u , int v)
{
	++tot;
	e[tot] = (edge){v , head[u]};
	head[u] = tot;
}
int dcmp(double x)
{
    if (x<=eps&&x>=-eps) return 0;
    return (x>0)?1:-1;
}

int main()
{

	scanf("%d%d%d%d" , &n , &m , &A , &B);
	for (int i = 1; i <= m; i++)
	{
		int u , v;
		scanf("%d%d" , &u , &v);
		addedge(u , v);
		addedge(v , u);
		deg[u] += 1.0;
		deg[v] += 1.0;
	}
	for (int i = 1; i <= n; i++) scanf("%lf" , &p[i]);
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			a[id(i , j)][id(i , j)] = 1;
			if (i != j) a[id(i , j)][id(i , j)] -= p[i] * p[j];
			for (int k = head[i]; k; k = e[k].nxt)
				if (e[k].to != j && e[k].to != i) a[id(i , j)][id(e[k].to , j)] -= (1 - p[e[k].to]) / deg[e[k].to] * p[j];
			for (int k = head[j]; k; k = e[k].nxt)
				if (i != e[k].to && j != e[k].to) a[id(i , j)][id(i , e[k].to)] -= (1 - p[e[k].to]) / deg[e[k].to] * p[i];
			for (int k = head[i]; k; k = e[k].nxt)
			{
				for (int l = head[j]; l; l = e[l].nxt)
				{
					if (e[k].to != e[l].to)
						a[id(i , j)][id(e[k].to , e[l].to)] -= (1 - p[e[k].to]) / deg[e[k].to] * (1 - p[e[l].to]) / deg[e[l].to];
				}
			}
		}
	}
	b[id(A , B)] = 1.0;
	for (int i=1;i<=n*n;++i)
    {
        int num=i;
        for (int j=i+1;j<=n*n;++j)
            if (dcmp(a[j][i]-a[num][i])>0) num=j;
        if (num!=i)
        {
            for (int j=1;j<=n*n;++j) swap(a[num][j],a[i][j]);
            swap(b[num],b[i]);
        }
        for (int j=i+1;j<=n*n;++j)
            if (dcmp(a[j][i]))
            {
                double t=a[j][i]/a[i][i];
                for (int k=1;k<=n*n;++k)
                    a[j][k]-=t*a[i][k];
                b[j]-=b[i]*t;
            }
    }
    for (int i=n*n;i>=1;--i)
    {
        for (int j=i+1;j<=n*n;++j) b[i]-=a[i][j]*ans[j];
        ans[i]=b[i]/a[i][i];
    }
	for (int i = 1; i <= n; i++) printf("%.6lf " , ans[id(i , i)]);
	printf("\n");

    return 0;
}


#include <iostream>
#include <vector>
#include <cmath>
#include <cstdio>
const int N=500;
using namespace std;
int read() {
	int x=0,f=1;char s=getchar();
	for(;s>'9'||s<'0';s=getchar()) if(s=='-') f=-1;
	for(;s>='0'&&s<='9';s=getchar()) x=x*10+s-'0';
	return x*f;
}
int n,m,a,b,ru[N],id[N][N];
vector<int> G[N];
double k[N],p[N],f[N][N];
void init() {
	f[id[a][b]][n*n+1]=-1;
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j) {
			--f[id[i][j]][id[i][j]];
			if(i!=j) f[id[i][j]][id[i][j]]+=p[i]*p[j];
			for(vector<int>::iterator it=G[i].begin();it!=G[i].end();++it) {
				if(*it==j) continue;
				f[id[i][j]][id[*it][j]]+=k[*it]*p[j];
			}
			for(vector<int>::iterator it=G[j].begin();it!=G[j].end();++it) {
				if(*it==i) continue;
				f[id[i][j]][id[i][*it]]+=k[*it]*p[i];
			}
			for(vector<int>::iterator it=G[i].begin();it!=G[i].end();++it) {
				for(vector<int>::iterator that=G[j].begin();that!=G[j].end();++that) {
					if(it==that) continue;
					f[id[i][j]][id[*it][*that]]+=k[*it]*k[*that];
				}
			}
		}
	}
}
double ans[N];
void gauss() {
	int N=n*n;
	for(int i=1;i<=N;++i) {
		int mx=i;
		for(int j=i+1;j<=N;++j)
			if(f[j][i]>f[mx][i]&&f[j][i]!=0) mx=i;
		if(mx!=i) swap(f[i],f[mx]);
		for(int j=1;j<=N;++j) {
			if(i==j) continue;
			double p=f[j][i]/f[i][i];
			for(int k=i;k<=N+1;k++) {
				f[j][k]-=f[i][k]*p;
			}
		}
	}
	for(int i=1;i<=N;++i) ans[i]=f[i][N+1]/f[i][i];
}
int main() {
	n=read(),m=read();
	a=read(),b=read();
	for(int i=1;i<=m;++i) {
		int x=read(),y=read();
		G[x].push_back(y);
		G[y].push_back(x);
		ru[x]++;
		ru[y]++;
	}
	for(int i=1;i<=n;++i) scanf("%lf",&p[i]);
	for(int i=1;i<=n;++i) k[i]=(1.0-p[i])/ru[i];
	for(int i=1,cnt=0;i<=n;++i)
		for(int j=1;j<=n;++j)
			id[i][j]=++cnt;
	init();
	gauss();
	for(int i=1;i<=n;++i) printf("%.10lf",ans[id[i][i]]);
	return 0;
}


#include <iostream>
#include <vector>
#include <cmath>
#include <cstdio>
const int N=500;
using namespace std;
int read() {
	int x=0,f=1;char s=getchar();
	for(;s>'9'||s<'0';s=getchar()) if(s=='-') f=-1;
	for(;s>='0'&&s<='9';s=getchar()) x=x*10+s-'0';
	return x*f;
}
int n,m,a,b,ru[N],id[N][N];
vector<int> G[N];
double k[N],p[N],f[N][N];
void init() {
	f[id[a][b]][n*n+1]=-1;
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j) {
			int sdgzy=id[i][j];
			--f[sdgzy][sdgzy];
			if(i!=j) f[sdgzy][sdgzy]+=p[i]*p[j];
			for(vector<int>::iterator x=G[i].begin();x!=G[i].end();++x) {
				for(vector<int>::iterator y=G[j].begin();y!=G[j].end();++y) {
					if(*x==*y) continue;
					f[sdgzy][id[*x][*y]]+=k[*x]*k[*y];
				}
			}
			for(vector<int>::iterator it=G[i].begin();it!=G[i].end();++it) {
				if(*it==j) continue;
				f[sdgzy][id[*it][j]]+=k[*it]*p[j];
			}
			for(vector<int>::iterator it=G[j].begin();it!=G[j].end();++it) {
				if(*it==i) continue;
				f[sdgzy][id[i][*it]]+=k[*it]*p[i];
			}
		}
	}
}
double ans[N];
void gauss() {
	int N=n*n;
	for(int i=1;i<=N;++i) {
		int mx=i;
		for(int j=i+1;j<=N;++j)
			if(f[j][i]>f[mx][i]&&f[j][i]!=0) mx=j;
		if(mx!=i) swap(f[i],f[mx]);
		for(int j=1;j<=N;++j) {
			if(i==j) continue;
			double p=f[j][i]/f[i][i];
			for(int k=i;k<=N+1;k++) {
				f[j][k]-=f[i][k]*p;
			}
		}
	}
	for(int i=1;i<=N;++i) f[i][i]=f[i][N+1]/f[i][i];
}
int main() {
	n=read(),m=read();
	a=read(),b=read();
	for(int i=1;i<=m;++i) {
		int x=read(),y=read();
		G[x].push_back(y);
		G[y].push_back(x);
		ru[x]++;
		ru[y]++;
	}
	for(int i=1;i<=n;++i) scanf("%lf",&p[i]);
	for(int i=1;i<=n;++i) k[i]=(1.0-p[i])/ru[i];
	for(int i=1,cnt=0;i<=n;++i)
		for(int j=1;j<=n;++j)
			id[i][j]=++cnt;
	init();
	gauss();
	for(int i=1;i<=n;++i) printf("%.10lf ",f[id[i][i]][id[i][i]]);
	return 0;
}


#include <algorithm>
#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;

const int N = 25;

int n, m, s, t, deg[N];
double mov[N], p[N];
vector<int> G[N];

double calc(int u, int v) {
    return u == v ? p[u] : mov[u];
}

int pos(int u, int v) {
    return (u - 1) * n + v;
}

double a[N * N][N * N];

void gauss(int n) {
    for(int i = 1, j = 1; i <= n; j = ++ i) {
        for(int k = i + 1; k <= n; k ++) if(fabs(a[j][i]) < fabs(a[k][i])) j = k;
        if(i != j) for(int k = i; k <= n + 1; k ++) swap(a[j][k], a[i][k]);
        if(fabs(a[i][i]) < 1e-17) puts("error!");
        for(j = i + 1; j <= n; j ++) {
            double z = a[j][i] / a[i][i];
            for(int k = i; k <= n + 1; k ++) a[j][k] -= z * a[i][k];
        }
    }
    for(int i = n; i >= 1; i --) {
        for(int j = i + 1; j <= n; j ++) a[i][n + 1] -= a[j][n + 1] * a[i][j];
        a[i][n + 1] /= a[i][i];
    }
}

int main() {
    scanf("%d%d%d%d", &n, &m, &s, &t);
    for(int u, v, i = 1; i <= m; i ++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
        deg[u] ++; deg[v] ++;
    }
    for(int i = 1; i <= n; i ++) {
        scanf("%lf", p + i);
        G[i].push_back(i);
        mov[i] = (1 - p[i]) / deg[i];
    }
    int k = n * n;
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= n; j ++) {
            int p = pos(i, j);
            a[p][p] = -1;
            if(i == s && j == t) a[p][k + 1] = -1;
            for(int x = 0; x < G[i].size(); x ++) {
                int u = G[i][x];
                for(int y = 0; y < G[j].size(); y ++) {
                    int v = G[j][y];
                    if(u == v) continue ;
                    a[p][pos(u, v)] += calc(u, i) * calc(v, j);
                }
            }
        }
    }
    gauss(k);
    for(int i = 1; i <= n; i ++)
        printf("%.10f ", fabs(a[pos(i, i)][k + 1]));
    return 0;
}
/*
f(s, t) = 1
f(i, j) = \sum_{ edge(u, i), edge(v, j), u != v} f(u, v) * calc(u, i) * calc(v, j)
calc(u, v) : u == v ? p[u] : mov[u]
*/


#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
const double eps=1e-9;

int n,m,A,B;
bool mp[30][30]; int deg[30]; double p[30];

double a[510][510],b[510],ans[510]; int pos[510];
void gauss(int n)
{
	for (int i=1;i<=n;i++) pos[i]=i;
	for (int i=1;i<=n;i++)
	{
		int maxpos=i;
		for (int j=i+1;j<=n;j++) if (fabs(a[i][j])>fabs(a[i][maxpos])+eps) maxpos=i;
		//No Solution
		if (i^maxpos)
		{
			swap(pos[i],pos[maxpos]);
			for (int j=1;j<=n;j++) swap(a[j][i],a[j][maxpos]);
		}
		for (int j=i+1;j<=n;j++)
		{
			double tmp=a[j][i]/a[i][i];
			for (int u=i;u<=n;u++) a[j][u]-=tmp*a[i][u];
			b[j]-=tmp*b[i];
		}
	}
	for (int i=n;i;i--)
	{
		for (int j=i+1;j<=n;j++) b[i]-=ans[pos[j]]*a[i][j];
		ans[pos[i]]=b[i]/a[i][i];
	}
}
int gethash(int x,int y)
{
	return (x-1)*n+y;
}
int main()
{
	scanf("%d%d%d%d",&n,&m,&A,&B);
	if (n==1) return puts("1.000000000"),0;
	for (int i=1,x,y;i<=m;i++)
	{
		scanf("%d%d",&x,&y); mp[x][y]=mp[y][x]=true; deg[x]++,deg[y]++;
	}
	for (int i=1;i<=n;i++) scanf("%lf",p+i);
	int x=gethash(A,B); b[x]+=-1;
	for (int i=1;i<=n;i++)
	{
		for (int j=1;j<=n;j++)
		{
			x=gethash(i,j);
			a[x][x]-=1;
			if (i==j) continue;
			for (int u=1;u<=n;u++)
				if (i==u||mp[i][u])
					for (int v=1;v<=n;v++)
						if (j==v||mp[j][v])
						{
							double y=(i==u?p[i]:(1-p[i])/deg[i])*(j==v?p[j]:(1-p[j])/deg[j]);   //caution deg i
							//printf("%d %d -> %d %d for %.5lf\n",i,j,u,v,y);
							a[gethash(u,v)][x]+=y;
						}
		}
	}
	/*for (int i=1;i<=n*n;printf(" %.5lf\n",b[i]),i++)
		for (int j=1;j<=n*n;j++)
			printf("%.5lf%c",a[i][j]," \n"[j==n*n+1]);*/
	gauss(n*n);
	for (int i=1;i<=n;i++) x=gethash(i,i),printf("%.9lf ",ans[x]); putchar('\n');
	return 0;
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <utility>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#define ri register int
#define pi acos(-1.0)

using namespace std;

inline char gch()
{
    static char buf[100010], *h = buf, *t = buf;
    return h == t && (t = (h = buf) + fread(buf, 1, 100000, stdin), h == t) ? EOF : *h ++;
}

typedef long long lo;

typedef long double ld;

const ld eps = 1e-6;

inline void re(int &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

inline void re(lo &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

int n, m, a, b, lx, ly, len, d[30];

ld p[30], mar[550][550];

bool mmp[30][30];

inline int askpos(int x, int y)
{
	return (n - 1) * (x - 1) + y - (x < y);
}

inline ld ask(int i, int j, int x, int y)
{
	ld rt = 0.0;
	if(i == x && j == y)
		rt = p[i] * p[j];
	else if(i == x && j != y)
		rt = p[i] * (1 - p[j]) / d[j] * mmp[j][y];
	else if(i != x && j == y)
		rt = p[j] * (1 - p[i]) / d[i] * mmp[i][x];
	else
		rt = (1 - p[i]) / d[i] * mmp[i][x] * (1 - p[j]) / d[j] * mmp[j][y];
	return rt;
}

int main()
{
	re(n), re(m), re(a), re(b), len = n * (n - 1);
	if(a == b)
	{
		for(ri i = 1; i <= n; i ++)
			printf("%d ", (i == a));
		return 0;
	}
	for(ri i = 1; i <= m; i ++)
		re(lx), re(ly), mmp[lx][ly] = mmp[ly][lx] = 1, d[lx] ++, d[ly] ++;
	for(ri i = 1; i <= n; i ++)
		cin >> p[i];
	for(ri i = 1; i <= n; i ++)
		for(ri j = 1; j <= n; j ++)
		{
			if(i == j)
				continue;
			int po = askpos(i, j); mar[po][po] = -1;
			for(ri x = 1; x <= n; x ++)
				for(ri y = 1; y <= n; y ++)
					if(x == y)
						mar[po][len + x] -= ask(i, j, x, y);
					else
						mar[po][askpos(x, y)] += ask(i, j, x, y);
		}
	//cout << askpos(n, n - 1) << ' ' << len << '\n';
	/*//for(ri i = 1; i <= len; cout << '\n', i ++)
	//	for(ri j = 1; j <= len + len; j ++)
	//		cout << mar[i][j] << ' ';
	for(ri i = 1; i <= len; i++) {
		if(fabsl(mar[i][i]) < eps) {
			ri pos = -1;
			for(ri j = i + 1; j <= len ; j++) {
				if(fabsl(mar[j][i]) >= eps) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mar[i],mar[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(ri j = i + 1; j <= len ; j++) {
			ld f = mar[j][i] / mar[i][i];
			for(ri k = i ; k <= n * n; k++) {
				mar[j][k] -= f* mar[i][k];
			}
		}
	}
	//??′ú
	for(ri i = len ; i >=1 ; i--) {
		ld f = mar[i][i];
		for(ri j = len + 1; j <= n * n ; j++) {
			mar[i][j] /= f;
		}
		mar[i][i] /= f;
		for(ri j = i - 1; j >= 1; j--) {
			ld f2 =  mar[j][i];
			mar[j][i] = 0;
			for(ri k = len + 1; k<= n * n; k++) {
				mar[j][k] -= f2 * mar[i][k];
			}
		}
	}*/
	/*for(ri i = 1; i <= len; i ++)
	{
		int no = i;
		for(ri j = i + 1; j <= len; j ++)
			no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
		for(ri j = i; j <= len + len; j ++)
			swap(mar[i][j], mar[no][j]);
		if(fabsl(mar[i][i]) < eps)
			return 0;
		for(ri j = i + 1; j <= len + len; j ++)
			mar[i][j] /= mar[i][i];
		mar[i][i] = 1;
		for(ri j = 1; j <= len; j ++)
		{
			if(i == j)
				continue;
			for(ri k = i + 1; k <= len + len; k ++)
				mar[j][k] -= mar[i][k] * mar[j][i];
			mar[j][i] = 0;
		}
	}*/
	for(ri i = 1; i <= len; i ++)
    {
        int no = i;
        for(ri j = i + 1; j <= len; j ++)
            no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
        for(ri j = i; j <= len + len; j ++)
            swap(mar[i][j], mar[no][j]);
        for(ri j = i + 1; j <= len; j ++)
        {
        	ld tmp = mar[j][i] / mar[i][i];
            for(ri k = i + 1; k <= len + len; k ++)
                mar[j][k] -= tmp * mar[i][k];
            mar[j][i] = 0;
        }
    }
    for(ri i = len; i > 0; i --)
    {
    	ld tmp = mar[i][i];
    	for(ri j = len + 1; j <= (len << 1); j ++)
    		mar[i][j] /= tmp;
    	mar[i][i] = 1;
    	for(ri j = i - 1; j > 0; j --)
    	{
    		ld Tmp = mar[j][i];
    		for(ri k = len + 1; k <= (len << 1); k ++)
    			mar[j][k] -= Tmp * mar[i][k];
    	}
    }
	int po = askpos(a, b);
	for(ri i = 1; i <= n; i ++)
		printf("%.10lf ", (double)mar[po][i + len]);
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <utility>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#define ri register int
#define pi acos(-1.0)

using namespace std;

inline char gch()
{
    static char buf[100010], *h = buf, *t = buf;
    return h == t && (t = (h = buf) + fread(buf, 1, 100000, stdin), h == t) ? EOF : *h ++;
}

typedef long long lo;

typedef long double ld;

const ld eps = 1e-6;

inline void re(int &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

inline void re(lo &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

int n, m, a, b, lx, ly, len, d[30];

ld p[30], mar[550][550];

bool mmp[30][30];

inline int askpos(int x, int y)
{
	return (n - 1) * (x - 1) + y - (x < y);
}

inline ld ask(int i, int j, int x, int y)
{
	ld rt = 0.0;
	if(i == x && j == y)
		rt = p[i] * p[j];
	else if(i == x && j != y)
		rt = p[i] * (1 - p[j]) / d[j] * mmp[j][y];
	else if(i != x && j == y)
		rt = p[j] * (1 - p[i]) / d[i] * mmp[i][x];
	else
		rt = (1 - p[i]) / d[i] * mmp[i][x] * (1 - p[j]) / d[j] * mmp[j][y];
	return rt;
}

int main()
{
	re(n), re(m), re(a), re(b), len = n * (n - 1);
	if(a == b)
	{
		for(ri i = 1; i <= n; i ++)
			printf("%d ", (i == a));
		return 0;
	}
	for(ri i = 1; i <= m; i ++)
		re(lx), re(ly), mmp[lx][ly] = mmp[ly][lx] = 1, d[lx] ++, d[ly] ++;
	for(ri i = 1; i <= n; i ++)
		cin >> p[i];
	for(ri i = 1; i <= n; i ++)
		for(ri j = 1; j <= n; j ++)
		{
			if(i == j)
				continue;
			int po = askpos(i, j); mar[po][po] = -1;
			for(ri x = 1; x <= n; x ++)
				for(ri y = 1; y <= n; y ++)
					if(x == y)
						mar[po][len + x] -= ask(i, j, x, y);
					else
						mar[po][askpos(x, y)] += ask(i, j, x, y);
		}
	//for(ri i = 1; i <= len; cout << '\n', i ++)
	//	for(ri j = 1; j <= len + len; j ++)
	//		cout << mar[i][j] << ' ';
	for(ri i = 1; i <= len; i ++)
	{
		int no = i;
		for(ri j = i + 1; j <= len; j ++)
			no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
		for(ri j = i; j <= len + len; j ++)
			swap(mar[i][j], mar[no][j]);
		if(fabsl(mar[i][i]) < eps)
			return 0;
		for(ri j = i + 1; j <= len + len; j ++)
			mar[i][j] /= mar[i][i];
		mar[i][i] = 1;
		for(ri j = 1; j <= len; j ++)
		{
			if(i == j)
				continue;
			for(ri k = i + 1; k <= len + len; k ++)
				mar[j][k] -= mar[i][k] * mar[j][i];
			mar[j][i] = 0;
		}
	}
	int po = askpos(a, b);
	for(ri i = 1; i <= n; i ++)
		printf("%.10lf ", (double)mar[po][i + len]);
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <utility>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#define ri register int
#define pi acos(-1.0)

using namespace std;

inline char gch()
{
    static char buf[100010], *h = buf, *t = buf;
    return h == t && (t = (h = buf) + fread(buf, 1, 100000, stdin), h == t) ? EOF : *h ++;
}

typedef long long lo;

typedef long double ld;

const ld eps = 1e-6;

inline void re(int &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

inline void re(lo &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

int n, m, a, b, lx, ly, len, d[30];

ld p[30], mar[550][550];

bool mmp[30][30];

inline int askpos(int x, int y)
{
	return (n - 1) * (x - 1) + y - (x < y);
}

inline ld ask(int i, int j, int x, int y)
{
	ld rt = 0.0;
	if(i == x && j == y)
		rt = p[i] * p[j];
	else if(i == x && j != y)
		rt = p[i] * (1 - p[j]) / d[j] * mmp[j][y];
	else if(i != x && j == y)
		rt = p[j] * (1 - p[i]) / d[i] * mmp[i][x];
	else
		rt = (1 - p[i]) / d[i] * mmp[i][x] * (1 - p[j]) / d[j] * mmp[j][y];
	return rt;
}

int main()
{
	re(n), re(m), re(a), re(b), len = n * (n - 1);
	if(a == b)
	{
		for(ri i = 1; i <= n; i ++)
			printf("%d ", (i == a));
		return 0;
	}
	for(ri i = 1; i <= m; i ++)
		re(lx), re(ly), mmp[lx][ly] = mmp[ly][lx] = 1, d[lx] ++, d[ly] ++;
	for(ri i = 1; i <= n; i ++)
		cin >> p[i];
	for(ri i = 1; i <= n; i ++)
		for(ri j = 1; j <= n; j ++)
		{
			if(i == j)
				continue;
			int po = askpos(i, j); mar[po][po] = -1;
			for(ri x = 1; x <= n; x ++)
				for(ri y = 1; y <= n; y ++)
					if(x == y)
						mar[po][len + x] -= ask(i, j, x, y);
					else
						mar[po][askpos(x, y)] += ask(i, j, x, y);
		}
	/*//for(ri i = 1; i <= len; cout << '\n', i ++)
	//	for(ri j = 1; j <= len + len; j ++)
	//		cout << mar[i][j] << ' ';
	for(ri i = 1; i <= len; i++) {
		if(fabsl(mar[i][i]) < eps) {
			ri pos = -1;
			for(ri j = i + 1; j <= len ; j++) {
				if(fabsl(mar[j][i]) >= eps) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mar[i],mar[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(ri j = i + 1; j <= len ; j++) {
			ld f = mar[j][i] / mar[i][i];
			for(ri k = i ; k <= n * n; k++) {
				mar[j][k] -= f* mar[i][k];
			}
		}
	}
	//??′ú
	for(ri i = len ; i >=1 ; i--) {
		ld f = mar[i][i];
		for(ri j = len + 1; j <= n * n ; j++) {
			mar[i][j] /= f;
		}
		mar[i][i] /= f;
		for(ri j = i - 1; j >= 1; j--) {
			ld f2 =  mar[j][i];
			mar[j][i] = 0;
			for(ri k = len + 1; k<= n * n; k++) {
				mar[j][k] -= f2 * mar[i][k];
			}
		}
	}*/
	/*for(ri i = 1; i <= len; i ++)
	{
		int no = i;
		for(ri j = i + 1; j <= len; j ++)
			no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
		for(ri j = i; j <= len + len; j ++)
			swap(mar[i][j], mar[no][j]);
		if(fabsl(mar[i][i]) < eps)
			return 0;
		for(ri j = i + 1; j <= len + len; j ++)
			mar[i][j] /= mar[i][i];
		mar[i][i] = 1;
		for(ri j = 1; j <= len; j ++)
		{
			if(i == j)
				continue;
			for(ri k = i + 1; k <= len + len; k ++)
				mar[j][k] -= mar[i][k] * mar[j][i];
			mar[j][i] = 0;
		}
	}*/
	for(ri i = 1; i <= len; i ++)
    {
        int no = i;
        for(ri j = i + 1; j <= len; j ++)
            no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
        for(ri j = i; j <= len + len; j ++)
            swap(mar[i][j], mar[no][j]);
        if(mar[i][i] == 0)
        {
            puts("No Solution"); return 0;
        }
        for(ri j = i + 1; j <= len + len; j ++)
            mar[i][j] = mar[i][j] / mar[i][i];
        mar[i][i] = 1;
        for(ri j = 1; j <= len; j ++)
        {
            if(i == j)
                continue;
            for(ri k = i + 1; k <= (len << 1); k ++)
                mar[j][k] -= mar[j][i] * mar[i][k];
            mar[j][i] = 0;
        }
    }
	int po = askpos(a, b);
	for(ri i = 1; i <= n; i ++)
		printf("%.10lf ", (double)mar[po][i + len]);
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <utility>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#define ri register int
#define pi acos(-1.0)

using namespace std;

inline char gch()
{
    static char buf[100010], *h = buf, *t = buf;
    return h == t && (t = (h = buf) + fread(buf, 1, 100000, stdin), h == t) ? EOF : *h ++;
}

typedef long long lo;

typedef long double ld;

const ld eps = 1e-6;

inline void re(int &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

inline void re(lo &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

int n, m, a, b, lx, ly, len, d[30];

ld p[30], mar[550][550];

bool mmp[30][30];

inline int askpos(int x, int y)
{
	return (n - 1) * (x - 1) + y - (x < y);
}

inline ld ask(int i, int j, int x, int y)
{
	ld rt = 0.0;
	if(i == x && j == y)
		rt = p[i] * p[j];
	else if(i == x && j != y)
		rt = p[i] * (1 - p[j]) / d[j] * mmp[j][y];
	else if(i != x && j == y)
		rt = p[j] * (1 - p[i]) / d[i] * mmp[i][x];
	else
		rt = (1 - p[i]) / d[i] * mmp[i][x] * (1 - p[j]) / d[j] * mmp[j][y];
	return rt;
}

int main()
{
	re(n), re(m), re(a), re(b), len = n * (n - 1);
	if(a == b)
	{
		for(ri i = 1; i <= n; i ++)
			printf("%d ", (i == a));
		return 0;
	}
	for(ri i = 1; i <= m; i ++)
		re(lx), re(ly), mmp[lx][ly] = mmp[ly][lx] = 1, d[lx] ++, d[ly] ++;
	for(ri i = 1; i <= n; i ++)
		cin >> p[i];
	for(ri i = 1; i <= n; i ++)
		for(ri j = 1; j <= n; j ++)
		{
			if(i == j)
				continue;
			int po = askpos(i, j); mar[po][po] = -1;
			for(ri x = 1; x <= n; x ++)
				for(ri y = 1; y <= n; y ++)
					if(x == y)
						mar[po][len + x] -= ask(i, j, x, y);
					else
						mar[po][askpos(x, y)] += ask(i, j, x, y);
		}
	//cout << askpos(n, n - 1) << ' ' << len << '\n';
	/*//for(ri i = 1; i <= len; cout << '\n', i ++)
	//	for(ri j = 1; j <= len + len; j ++)
	//		cout << mar[i][j] << ' ';
	for(ri i = 1; i <= len; i++) {
		if(fabsl(mar[i][i]) < eps) {
			ri pos = -1;
			for(ri j = i + 1; j <= len ; j++) {
				if(fabsl(mar[j][i]) >= eps) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mar[i],mar[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(ri j = i + 1; j <= len ; j++) {
			ld f = mar[j][i] / mar[i][i];
			for(ri k = i ; k <= n * n; k++) {
				mar[j][k] -= f* mar[i][k];
			}
		}
	}
	//??′ú
	for(ri i = len ; i >=1 ; i--) {
		ld f = mar[i][i];
		for(ri j = len + 1; j <= n * n ; j++) {
			mar[i][j] /= f;
		}
		mar[i][i] /= f;
		for(ri j = i - 1; j >= 1; j--) {
			ld f2 =  mar[j][i];
			mar[j][i] = 0;
			for(ri k = len + 1; k<= n * n; k++) {
				mar[j][k] -= f2 * mar[i][k];
			}
		}
	}*/
	for(ri i = 1; i <= len; i ++)
	{
		int no = i;
		for(ri j = i + 1; j <= len; j ++)
			no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
		for(ri j = i; j <= n * n; j ++)
			swap(mar[i][j], mar[no][j]);
		if(fabsl(mar[i][i]) < eps)
			return 0;
		for(ri j = i + 1; j <= n * n; j ++)
			mar[i][j] /= mar[i][i];
		mar[i][i] = 1;
		for(ri j = 1; j <= len; j ++)
		{
			if(i == j)
				continue;
			for(ri k = i + 1; k <= n * n; k ++)
				mar[j][k] -= mar[i][k] * mar[j][i];
			mar[j][i] = 0;
		}
	}
	/*for(ri i = 1; i <= len; i ++)
    {
        int no = i;
        for(ri j = i + 1; j <= len; j ++)
            no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
        for(ri j = i; j <= len + len; j ++)
            swap(mar[i][j], mar[no][j]);
        for(ri j = i + 1; j <= len; j ++)
        {
        	ld tmp = mar[j][i] / mar[i][i];
            for(ri k = i + 1; k <= n * n; k ++)
                mar[j][k] -= tmp * mar[i][k];
            mar[j][i] = 0;
        }
    }
    for(ri i = len; i > 0; i --)
    {
    	ld tmp = mar[i][i];
    	for(ri j = len + 1; j <= (len << 1); j ++)
    		mar[i][j] /= tmp;
    	mar[i][i] = 1;
    	for(ri j = i - 1; j > 0; j --)
    	{
    		ld Tmp = mar[j][i];
    		for(ri k = len + 1; k <= (len << 1); k ++)
    			mar[j][k] -= Tmp * mar[i][k];
    	}
    }*/
	int po = askpos(a, b);
	for(ri i = 1; i <= n; i ++)
		printf("%.10lf ", (double)mar[po][i + len]);
}


#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <utility>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <set>
#define ri register int
#define pi acos(-1.0)

using namespace std;

inline char gch()
{
    static char buf[100010], *h = buf, *t = buf;
    return h == t && (t = (h = buf) + fread(buf, 1, 100000, stdin), h == t) ? EOF : *h ++;
}

typedef long long lo;

typedef long double ld;

const ld eps = 1e-6;

inline void re(int &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

inline void re(lo &x)
{
    x = 0;
    char a; bool b = 0;
    while(!isdigit(a = getchar()))
        b = a == '-';
    while(isdigit(a))
        x = x * 10 + a - '0', a = getchar();
    if(b == 1)
        x = - x;
}

int n, m, a, b, lx, ly, len, d[30];

ld p[30], mar[550][550];

bool mmp[30][30];

inline int askpos(int x, int y)
{
	return (n - 1) * (x - 1) + y - (x < y);
}

inline ld ask(int i, int j, int x, int y)
{
	ld rt = 0.0;
	if(i == x && j == y)
		rt = p[i] * p[j];
	else if(i == x && j != y)
		rt = p[i] * (1 - p[j]) / d[j] * mmp[j][y];
	else if(i != x && j == y)
		rt = p[j] * (1 - p[i]) / d[i] * mmp[i][x];
	else
		rt = (1 - p[i]) / d[i] * mmp[i][x] * (1 - p[j]) / d[j] * mmp[j][y];
	return rt;
}

int main()
{
	re(n), re(m), re(a), re(b), len = n * (n - 1);
	if(a == b)
	{
		for(ri i = 1; i <= n; i ++)
			printf("%d ", (i == a));
		return 0;
	}
	for(ri i = 1; i <= m; i ++)
		re(lx), re(ly), mmp[lx][ly] = mmp[ly][lx] = 1, d[lx] ++, d[ly] ++;
	for(ri i = 1; i <= n; i ++)
		cin >> p[i];
	for(ri i = 1; i <= n; i ++)
		for(ri j = 1; j <= n; j ++)
		{
			if(i == j)
				continue;
			int po = askpos(i, j); mar[po][po] = -1;
			for(ri x = 1; x <= n; x ++)
				for(ri y = 1; y <= n; y ++)
					if(x == y)
						mar[po][len + x] -= ask(i, j, x, y);
					else
						mar[po][askpos(x, y)] += ask(i, j, x, y);
		}
	//for(ri i = 1; i <= len; cout << '\n', i ++)
	//	for(ri j = 1; j <= len + len; j ++)
	//		cout << mar[i][j] << ' ';
	for(ri i = 1; i <= len; i++) {
		if(fabsl(mar[i][i]) < eps) {
			ri pos = -1;
			for(ri j = i + 1; j <= len ; j++) {
				if(fabsl(mar[j][i]) >= eps) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mar[i],mar[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(ri j = i + 1; j <= len ; j++) {
			ld f = mar[j][i] / mar[i][i];
			for(ri k = i ; k <= n * n; k++) {
				mar[j][k] -= f* mar[i][k];
			}
		}
	}
	//??′ú
	for(ri i = len ; i >=1 ; i--) {
		ld f = mar[i][i];
		for(ri j = len + 1; j <= n * n ; j++) {
			mar[i][j] /= f;
		}
		mar[i][i] /= f;
		for(ri j = i - 1; j >= 1; j--) {
			ld f2 =  mar[j][i];
			mar[j][i] = 0;
			for(ri k = len + 1; k<= n * n; k++) {
				mar[j][k] -= f2 * mar[i][k];
			}
		}
	}
	/*for(ri i = 1; i <= len; i ++)
	{
		int no = i;
		for(ri j = i + 1; j <= len; j ++)
			no = (fabsl(mar[no][i]) < fabsl(mar[j][i])) ? j : no;
		for(ri j = i; j <= len + len; j ++)
			swap(mar[i][j], mar[no][j]);
		if(fabsl(mar[i][i]) < eps)
			return 0;
		for(ri j = i + 1; j <= len + len; j ++)
			mar[i][j] /= mar[i][i];
		mar[i][i] = 1;
		for(ri j = 1; j <= len; j ++)
		{
			if(i == j)
				continue;
			for(ri k = i + 1; k <= len + len; k ++)
				mar[j][k] -= mar[i][k] * mar[j][i];
			mar[j][i] = 0;
		}
	}*/
	int po = askpos(a, b);
	for(ri i = 1; i <= n; i ++)
		printf("%.10lf ", (double)mar[po][i + len]);
}


#include<bits/stdc++.h>
#define RG register
#define IL inline
#define eps (1e-10)
using namespace std;
int g[24][24],num[24][24],cnt;
int S,T,n,m;
double fun[23*23][24*24];
int du[24];
double P1[24],P2[24];
IL void guass(){
	int N = cnt;
	for(RG int i=1,I;i<=N;++i){
		I = i;
		for(RG int j=I;j<=N;++j)if(fabs(fun[j][i])-fabs(fun[I][i])>eps) I = j;
		if(I!=i)swap(fun[I],fun[i]);
		for(RG int j=N+1;j>=i;--j)fun[i][j]/=fun[i][i];
		for(RG int j=1;j<=N;++j)if(i!=j)for(RG int D = N+1;D>=i;--D) fun[j][D]-=fun[j][i]*fun[i][D];
	}return;
}
int main(){
	scanf("%d%d%d%d",&n,&m,&S,&T);
	for(RG int i=1;i<=m;++i){
		RG int a, b;
		scanf("%d%d",&a,&b);
		g[a][b]=g[b][a]=1;++du[a],++du[b];
	}
	for(RG int i=1;i<=n;++i)g[i][i]=1,scanf("%lf",&P1[i]),P2[i]=(1-P1[i])/du[i];
	for(RG int i=1;i<=n;++i)
		for(RG int j=1;j<=n;++j)
			num[i][j]=++cnt;
	for(RG int i=1;i<=n;++i){
		for(RG int j=1;j<=n;++j){
			if(i!=j)fun[num[i][j]][num[i][j]]=P1[i]*P1[j]-1;
			else fun[num[i][j]][num[i][j]]=-1;
			for(RG int ii=1;ii<=n;++ii){
				if(!g[i][ii])continue;
				for(RG int jj = 1;jj<=n;++jj){
					if(!g[j][jj])continue;
					if(ii==jj)continue;
					if(i==ii&&j==jj)continue;
					RG double p1,p2;
					p1=i==ii?P1[ii]:P2[ii];
					p2=j==jj?P1[jj]:P2[jj];
					fun[num[i][j]][num[ii][jj]]+=p1*p2;
				}
			}
		}
	}
	fun[num[S][T]][cnt+1]=-1;
	guass();
	for(RG int i=1;i<=n;++i)printf("%.10lf ",fun[num[i][i]][cnt+1]);
}


#include<bits/stdc++.h>
#define eps 1e-7
#define MAXN 2310
using namespace std;
inline int read ()
{
	int s=0,w=1;
	char ch=getchar ();
	while (ch<'0'||ch>'9'){if (ch=='-') w=-1;ch=getchar ();}
	while ('0'<=ch&&ch<='9') s=(s<<1)+(s<<3)+(ch^48),ch=getchar ();
	return s*w;
}
int n,m,S,T,tot,lim;
int deg[MAXN],id[MAXN][MAXN];
vector<int>e[MAXN];
double p[MAXN],a[MAXN][MAXN];
void gauss ()
{
	for (int i=1;i<=lim;i++)
	{
		int p=i;
		for (int j=i;j<=lim;j++)
			if (fabs (a[j][i]-a[p][i])<=eps)
				p=j;
		for (int j=1;j<=lim+1;j++) swap (a[i][j],a[p][j]);
		for (int j=i+1;j<=lim+1;j++) a[i][j]/=a[i][i];
		for (int j=1;j<=lim;j++)
			if (i!=j)
				for (int k=i+1;k<=lim+1;k++)
					a[j][k]-=a[j][i]*a[i][k];
	}
}
int main()
{
	n=read (),m=read (),S=read (),T=read (),lim=n*n;
	for (int i=1;i<=m;i++)
	{
		int u=read (),v=read ();
		e[u].push_back (v),e[v].push_back (u);
		deg[u]++,deg[v]++;
	}
	for (int i=1;i<=n;i++) scanf ("%lf",&p[i]);
	for (int i=1;i<=n;i++)
		for (int j=1;j<=n;j++)
			id[i][j]=++tot;
	a[id[S][T]][lim+1]=-1;
	for (int i=1;i<=n;i++)
		for (int j=1;j<=n;j++)
		{
			int u=id[i][j];
			a[u][u]--;
			if (i!=j) a[u][u]+=p[i]*p[j];
			for (auto x:e[i])
				for (auto y:e[j])
				{
					if (x==y) continue;
					int nxt=id[x][y];
					a[u][nxt]+=(1.0-p[x])*(1.0-p[y])/deg[x]/deg[y];
				}
			for (auto x:e[i])
			{
				int nxt=id[x][j];
				if (x==j) continue;
				a[u][nxt]+=(1.0-p[x])*p[j]/deg[x];
			}
			for (auto y:e[j])
			{
				int nxt=id[i][y];
				if (i==y) continue;
				a[u][nxt]+=p[i]*(1.0-p[y])/deg[y];
			}
		}
	gauss ();
	for (int i=1;i<=n;i++) printf ("%.7lf ",fabs (a[id[i][i]][lim+1]/a[id[i][i]][id[i][i]]));
	return 0;
}


#include<bits/stdc++.h>
#define MAXN 2310
using namespace std;
inline int read ()
{
	int s=0,w=1;
	char ch=getchar ();
	while (ch<'0'||ch>'9'){if (ch=='-') w=-1;ch=getchar ();}
	while ('0'<=ch&&ch<='9') s=(s<<1)+(s<<3)+(ch^48),ch=getchar ();
	return s*w;
}
int n,m,S,T,tot,lim;
int deg[MAXN];
vector<int>e[MAXN];
double p[MAXN],f[MAXN][MAXN];
int main()
{
	n=read (),m=read (),S=read (),T=read (),lim=n*n;
	for (int i=1;i<=m;i++)
	{
		int u=read (),v=read ();
		e[u].push_back (v),e[v].push_back (u);
		deg[u]++,deg[v]++;
	}
	for (int i=1;i<=n;i++) scanf ("%ld",p[i]);
	for (int i=1;i<=n;i++)
		for (int j=1;j<=n;j++)
			id[i][j]=++tot;
	f[id[a][b]][lim+1]=-1;
	for (int i=1;i<=n;i++)
		for (int j=1;j<=n;j++)
		{
			int u=id[i][j];
			f[u][u]--;
			if (i!=j) f[u][u]+=p[i]*p[j];
			for (auto x:e[i])
				for (auto y:e[j])
				{
					if (x==y) continue;
					int nxt=id[x][y];
					f[u][nxt]+=(1.0-p[x])*(1.0-p[y])/deg[x]/deg[y];
				}
			for (auto x:e[i])
			{
				int nxt=id[x][j];
				if (x==j) continue;
				f[u][nxt]+=(1.0-p[x])*p[j]/deg[x];
			}
			for (auto y:e[j])
			{
				int nxt=id[i][y];
				if (i==y) continue;
				f[u][nxt]+=p[i]*(1.0-p[y])/deg[y];
			}
		}
	return 0;
}


#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
#include<assert.h>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 25;
const int maxN = 505;
In ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
In void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}
In void MYFILE()
{
#ifndef mrclr
  freopen(".in", "r", stdin);
  freopen(".out", "w", stdout);
#endif
}

int n, m, A, B, cnt;
db p[maxn];
struct Edge
{
  int nxt, to;
}e[maxn * maxn * 2];
int head[maxn], ecnt = -1, du[maxn];
In void addEdge(int x, int y)
{
  ++du[x];
  e[++ecnt] = (Edge){head[x], y};
  head[x] = ecnt;
}

In int N(int x, int y) {return (x - 1) * n  + y;}

db f[maxN][maxN], ans[maxN];
In void init()
{
  f[N(A, B)][cnt + 1] = 1;
  for(int i = 1; i <= n; ++i)
    for(int j = 1; j <= n; ++j)
      {
    int u = N(i, j);
    f[u][u] = 1;
    if(i ^ j) f[u][u] -= p[i] * p[j];
    for(int k = head[j], v; ~k; k = e[k].nxt)
      if((v = e[k].to) ^ i) f[u][N(i, v)] -= p[i] * (1 - p[v]) / du[v];
    for(int k = head[i], v; ~k; k = e[k].nxt)
      if((v = e[k].to) ^ j) f[u][N(v, j)] -= p[j] * (1 - p[v]) / du[v];
    for(int k = head[i], v1; ~k; k = e[k].nxt)
      for(int h = head[j], v2; ~h; h = e[h].nxt)
        if((v1 = e[k].to) ^ (v2 = e[h].to))
          f[u][N(v1, v2)] -= (1 - p[v1]) * (1 - p[v2]) / du[v1] / du[v2];
      }
}
In void Gauss()
{
  for(int i = 1; i <= cnt; ++i)
    {
      int pos = i;
      for(int j = i + 1; j <= cnt; ++j)
    if(fabs(f[j][i]) > fabs(f[pos][i])) pos = j;
      if(pos ^ i) swap(f[pos], f[i]);
      if(fabs(f[i][i]) < eps) continue;
      db tp = f[i][i];
      for(int j = i; j <= cnt + 1; ++j) f[i][j] /= tp;
      for(int j = i + 1; j <= cnt; ++j)
    {
      db tp = f[j][i];
      for(int k = i; k <= cnt + 1; ++k) f[j][k] -= tp * f[i][k];
    }
    }
  for(int i = cnt; i; --i)
    {
      ans[i] = f[i][cnt + 1];
      for(int j = i - 1; j; --j) f[j][cnt + 1] -= f[j][i] * ans[i];
    }
}

int main()
{
  //MYFILE();
  Mem(head, -1);
  n = read(), m = read(), A = read(), B = read();
  cnt = n * n;
  for(int i = 1; i <= m; ++i)
    {
      int x = read(), y = read();
      addEdge(x, y), addEdge(y, x);
    }
  for(int i = 1; i <= n; ++i) scanf("%lf", &p[i]);
  init(), Gauss();
  for(int i = 1; i <= n; ++i) printf("%.8lf\n", ans[N(i, i)]);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define Mem(a, x) memset(a, x, sizeof(a))
typedef long long ll;
typedef double db;
const int INF=0x3f3f3f3f;
const db eps=1e-8;
const int maxn=25, maxN=505;
db f[maxN][maxN], ans[maxN];
int n,m,A,B,cnt;
db p[maxn];
struct Edge
{
  int nxt,to;
}e[maxn*maxn*2];
int head[maxn], ecnt=-1, du[maxn];

ll read()
{
  ll ans=0;
  char ch=getchar(), last=' ';
  while(!isdigit(ch)) last=ch, ch=getchar();
  while(isdigit(ch)) ans=(ans<<1)+(ans<<3)+ch-'0',ch=getchar();
  if(last=='-') ans=-ans;
  return ans;
}

void write(ll x)
{
  if(x<0) x=-x, putchar('-');
  if(x>=10) write(x/10);
  putchar(x%10+'0');
}

void addEdge(int x, int y)
{
  ++du[x]; e[++ecnt]=(Edge){head[x],y}; head[x]=ecnt;
}

int N(int x, int y)
{
	return (x-1)*n +y;
}

void init()
{
  f[N(A,B)][cnt+1]=1;
  for(int i=1; i<=n; ++i)
    for(int j=1; j<=n; ++j)
    {
    	int u=N(i, j);
    	f[u][u]=1;
    	if(i^j) f[u][u]-=p[i]*p[j];
    	for(int k=head[j], v; ~k; k=e[k].nxt)
        if((v=e[k].to)^i) f[u][N(i,v)]-=p[i]*(1-p[v])/du[v];
    	for(int k=head[i], v; ~k; k=e[k].nxt)
        if((v=e[k].to)^j) f[u][N(v,j)]-=p[j]*(1-p[v])/du[v];
    	for(int k=head[i], v1; ~k; k=e[k].nxt)
      	for(int h=head[j], v2; ~h; h=e[h].nxt)
        	if((v1=e[k].to)^(v2=e[h].to))
            f[u][N(v1,v2)]-=(1-p[v1])*(1-p[v2])/du[v1]/du[v2];
    }
}

void Gauss()
{
  for(int i=1; i<=cnt; ++i)
  {
    int pos=i;
    for(int j=i+1; j<=cnt; ++j)
      if(fabs(f[j][i])>fabs(f[pos][i])) pos=j;
    if(pos^i) swap(f[pos],f[i]);
    if(fabs(f[i][i])<eps) continue;
    db tp=f[i][i];
    for(int j=i; j<=cnt+1; ++j) f[i][j]/=tp;
    for(int j=i+1; j<=cnt; ++j)
    {
      db tp=f[j][i];
      for(int k=i; k<=cnt+1; ++k) f[j][k]-=tp*f[i][k];
    }
  }
  for(int i=cnt; i; --i)
  {
    ans[i]=f[i][cnt+1];
    for(int j=i-1; j; --j) f[j][cnt+1]-=f[j][i]*ans[i];
  }
}

int main()
{
  Mem(head, -1);
  n=read(), m=read(), A=read(), B=read(); cnt=n*n;
  for(int i=1; i<=m; ++i)
  {
    int x=read(), y=read();
    addEdge(x,y), addEdge(y,x);
  }
  for(int i=1; i<=n; ++i) scanf("%lf",&p[i]);
  init(), Gauss();
  for(int i=1; i<=n; ++i) printf("%.8lf\n",ans[N(i,i)]);
  return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <stack>

using namespace std;

int m, n, a, b;

const double eps = 0.00000000001;

double mat[1024][1024], pp[32][32], f[1024], p[32], ans[1024];
vector<int> G[32];

void GaussElimination(int nn)
{
    int r = 1;
    for (int i = 1; i <= nn; i++)
    {
        for (int j = r; j <= nn; j++)
        {
            if (fabs(mat[j][i]) > eps)
            {
                for (int k = i; k <= nn + 1; k++) swap(mat[j][k], mat[r][k]); break;
            }
        }
        for (int j = 1; j <= nn; j++)
        {
            if (j != r && fabs(mat[j][i]) > eps)
            {
                double tmp = mat[j][i] / mat[r][i];
                for (int k = i; k <= nn + 1; k++)
                {
                    mat[j][k] -= tmp * mat[r][k];
                }
            }
        }
        ++r;
    }
    /*for (int i = 1; i <= nn; i++)
    {
        for (int j = 1; j <= nn + 1; j++) cout << mat[i][j] << ' '; cout << endl;
    }*/
    for (int i = 1; i <= nn; i++)
    {
        //for (int j = 1; j <= nn; j++)
        //{
            ans[i] = mat[i][nn + 1] / mat[i][i];
        //}
    }
}

int encode(int x, int y)
{
    if (x > y) swap(x, y);
    int ans = 0;
    int beg = n - 1;
    int fin = n - x;
    ans = ((beg + fin) * x / 2);
    ans = ans - n + y;
    return ans;
}

pair<int, int> decode(int x)
{
    int t = n - 1;
    int tot = n - 1;
    int t1 = 1;
    while (tot < x)
    {
        t--;
        tot += t;
        t1++;
    }
    int t2 = n - (tot - x);
    return pair<int, int> (t1, t2);
}

int main()
{
    scanf("%d%d%d%d", &n, &m, &a, &b);
    for (int i = 1; i <= m; i++)
    {
        int tx, ty;
        scanf("%d%d", &tx, &ty);
        G[tx].push_back(ty);
        G[ty].push_back(tx);
    }
    memset(pp, 0, sizeof(pp));
    for (int i = 1; i <= n; i++)
    {
        scanf("%lf", &p[i]);
        pp[i][i] = p[i];
        double t = 1.0 - p[i];
        t /= (double)G[i].size();
        for (int j = 0; j < G[i].size(); j++)
        {
            pp[i][G[i][j]] = t;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        G[i].push_back(i);
    }
    for (int cnt = 1; cnt <= n; cnt++)
    {
        //memset(f, 0, sizeof(f));
        /*
        for (int i = 1; i <= n; i++)
        {
            f[i][i] = 0;
        }
        f[cnt][cnt] = 1;*/
        if (a == b)
        {
            for (int i = 1; i <= n; i++)
            {
                if (i != a) printf("%lf\n", 0.0);
                else printf("%lf\n", 1.0);
            }
            break;
        }
        memset(mat, 0, sizeof(mat));
        memset(ans, 0, sizeof(ans));
        int trash = 0;
        for (int i = 1; i < n; i++)
        {
            for (int j = i + 1; j <= n; j++)
            {
                trash++;
                for (int k = 0; k < G[i].size(); k++)
                {
                    for (int l = 0; l < G[j].size(); l++)
                    {
                        if (G[i][k] != G[j][l])
                        {
                            mat[trash][encode(G[i][k], G[j][l])] += (pp[i][G[i][k]] * pp[j][G[j][l]]) * 1.0;
                        }
                        else if (G[i][k] == cnt) mat[trash][encode(n - 1, n) + 1] -= (pp[i][G[i][k]] * pp[j][G[j][l]]) * 1.0;
                    }
                }
                mat[trash][encode(i, j)] -= 1.0;
            }
        }
        /*for (int i = 1; i <= encode(n - 1, n); i++)
        {
            for (int j = 1; j <= encode(n - 1, n) + 1; j++) cout << mat[i][j] << " ";
            cout << endl;
        }*/
        GaussElimination(encode(n - 1, n));
        printf("%lf\n", ans[encode(a, b)]);
    }
    /*n = 22;
    while (1)
    {
        //int a, b;
        cin >> a;
        cout << decode(a).first << " " << decode(a).second << endl;
    }*/
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <stack>

using namespace std;

int m, n, a, b;

const double eps = 0.00000000001;

double mat[1024][1024], pp[32][32], f[1024], p[32], ans[1024];
vector<int> G[32];

void GaussElimination(int nn)
{
    int r = 1;
    for (int i = 1; i <= nn; i++)
    {
        for (int j = r; j <= nn; j++)
        {
            if (fabs(mat[j][i]) > eps)
            {
                for (int k = i; k <= nn + 1; k++) swap(mat[j][k], mat[r][k]); break;
            }
        }
        for (int j = 1; j <= nn; j++)
        {
            if (j != r && fabs(mat[j][i]) > eps)
            {
                double tmp = mat[j][i] / mat[r][i];
                for (int k = i; k <= nn + 1; k++)
                {
                    mat[j][k] -= tmp * mat[r][k];
                }
            }
        }
        ++r;
    }
    /*for (int i = 1; i <= nn; i++)
    {
        for (int j = 1; j <= nn + 1; j++) cout << mat[i][j] << ' '; cout << endl;
    }*/
    for (int i = 1; i <= nn; i++)
    {
        //for (int j = 1; j <= nn; j++)
        //{
            ans[i] = mat[i][nn + 1] / mat[i][i];
        //}
    }
}

int encode(int x, int y)
{
    if (x > y) swap(x, y);
    int ans = 0;
    int beg = n - 1;
    int fin = n - x;
    ans = ((beg + fin) * x / 2);
    ans = ans - n + y;
    return ans;
}

pair<int, int> decode(int x)
{
    int t = n - 1;
    int tot = n - 1;
    int t1 = 1;
    while (tot < x)
    {
        t--;
        tot += t;
        t1++;
    }
    int t2 = n - (tot - x);
    return pair<int, int> (t1, t2);
}

int main()
{
    scanf("%d%d%d%d", &n, &m, &a, &b);
    for (int i = 1; i <= m; i++)
    {
        int tx, ty;
        scanf("%d%d", &tx, &ty);
        G[tx].push_back(ty);
        G[ty].push_back(tx);
    }
    memset(pp, 0, sizeof(pp));
    for (int i = 1; i <= n; i++)
    {
        scanf("%lf", &p[i]);
        pp[i][i] = p[i];
        double t = 1.0 - p[i];
        t /= (double)G[i].size();
        for (int j = 0; j < G[i].size(); j++)
        {
            pp[i][G[i][j]] = t;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        G[i].push_back(i);
    }
    for (int cnt = 1; cnt <= n; cnt++)
    {
        //memset(f, 0, sizeof(f));
        /*
        for (int i = 1; i <= n; i++)
        {
            f[i][i] = 0;
        }
        f[cnt][cnt] = 1;*/
        memset(mat, 0, sizeof(mat));
        memset(ans, 0, sizeof(ans));
        int trash = 0;
        for (int i = 1; i < n; i++)
        {
            for (int j = i + 1; j <= n; j++)
            {
                trash++;
                for (int k = 0; k < G[i].size(); k++)
                {
                    for (int l = 0; l < G[j].size(); l++)
                    {
                        if (G[i][k] != G[j][l])
                        {
                            mat[trash][encode(G[i][k], G[j][l])] += (pp[i][G[i][k]] * pp[j][G[j][l]]) * 1.0;
                        }
                        else if (G[i][k] == cnt) mat[trash][encode(n - 1, n) + 1] -= (pp[i][G[i][k]] * pp[j][G[j][l]]) * 1.0;
                    }
                }
                mat[trash][encode(i, j)] -= 1.0;
            }
        }
        /*for (int i = 1; i <= encode(n - 1, n); i++)
        {
            for (int j = 1; j <= encode(n - 1, n) + 1; j++) cout << mat[i][j] << " ";
            cout << endl;
        }*/
        GaussElimination(encode(n - 1, n));
        printf("%lf\n", ans[encode(a, b)]);
    }
    /*n = 22;
    while (1)
    {
        //int a, b;
        cin >> a;
        cout << decode(a).first << " " << decode(a).second << endl;
    }*/
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <stack>

using namespace std;

int m, n, a, b;

const double eps = 0.00000000001;

double mat[1024][1024], pp[32][32], f[1024], p[32], ans[1024];
vector<int> G[32];

void GaussElimination(int nn)
{
    int r = 1;
    for (int i = 1; i <= nn; i++)
    {
        for (int j = r; j <= nn; j++)
        {
            if (fabs(mat[j][i]) > eps)
            {
                for (int k = i; k <= nn + 1; k++) swap(mat[j][k], mat[r][k]); break;
            }
        }
        for (int j = 1; j <= nn; j++)
        {
            if (j != r && fabs(mat[j][i]) > eps)
            {
                double tmp = mat[j][i] / mat[r][i];
                for (int k = i; k <= nn + 1; k++)
                {
                    mat[j][k] -= tmp * mat[r][k];
                }
            }
        }
        ++r;
    }
    /*for (int i = 1; i <= nn; i++)
    {
        for (int j = 1; j <= nn + 1; j++) cout << mat[i][j] << ' '; cout << endl;
    }*/
    for (int i = 1; i <= nn; i++)
    {
        //for (int j = 1; j <= nn; j++)
        //{
            ans[i] = mat[i][nn + 1] / mat[i][i];
        //}
    }
}

int encode(int x, int y)
{
    if (x > y) swap(x, y);
    int ans = 0;
    int beg = n - 1;
    int fin = n - x;
    ans = ((beg + fin) * x / 2);
    ans = ans - n + y;
    return ans;
}

pair<int, int> decode(int x)
{
    int t = n - 1;
    int tot = n - 1;
    int t1 = 1;
    while (tot < x)
    {
        t--;
        tot += t;
        t1++;
    }
    int t2 = n - (tot - x);
    return pair<int, int> (t1, t2);
}

int main()
{
    scanf("%d%d%d%d", &n, &m, &a, &b);
    for (int i = 1; i <= m; i++)
    {
        int tx, ty;
        scanf("%d%d", &tx, &ty);
        G[tx].push_back(ty);
        G[ty].push_back(tx);
    }
    memset(pp, 0, sizeof(pp));
    for (int i = 1; i <= n; i++)
    {
        scanf("%lf", &p[i]);
        pp[i][i] = p[i];
        double t = 1.0 - p[i];
        t /= (double)G[i].size();
        for (int j = 0; j < G[i].size(); j++)
        {
            pp[i][G[i][j]] = t;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        G[i].push_back(i);
    }
    for (int cnt = 1; cnt <= n; cnt++)
    {
        //memset(f, 0, sizeof(f));
        /*
        for (int i = 1; i <= n; i++)
        {
            f[i][i] = 0;
        }
        f[cnt][cnt] = 1;*/
        if (n == 1) { printf("%lf\n", 1.0); break; }
        memset(mat, 0, sizeof(mat));
        memset(ans, 0, sizeof(ans));
        int trash = 0;
        for (int i = 1; i < n; i++)
        {
            for (int j = i + 1; j <= n; j++)
            {
                trash++;
                for (int k = 0; k < G[i].size(); k++)
                {
                    for (int l = 0; l < G[j].size(); l++)
                    {
                        if (G[i][k] != G[j][l])
                        {
                            mat[trash][encode(G[i][k], G[j][l])] += (pp[i][G[i][k]] * pp[j][G[j][l]]) * 1.0;
                        }
                        else if (G[i][k] == cnt) mat[trash][encode(n - 1, n) + 1] -= (pp[i][G[i][k]] * pp[j][G[j][l]]) * 1.0;
                    }
                }
                mat[trash][encode(i, j)] -= 1.0;
            }
        }
        /*for (int i = 1; i <= encode(n - 1, n); i++)
        {
            for (int j = 1; j <= encode(n - 1, n) + 1; j++) cout << mat[i][j] << " ";
            cout << endl;
        }*/
        GaussElimination(encode(n - 1, n));
        printf("%lf\n", ans[encode(a, b)]);
    }
    /*n = 22;
    while (1)
    {
        //int a, b;
        cin >> a;
        cout << decode(a).first << " " << decode(a).second << endl;
    }*/
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int read(){
	int a=0,b=getchar(),c=1;
	while(!isdigit(b))c=b=='-'?-1:1,b=getchar();
	while(isdigit(b))a=a*10+b-'0',b=getchar();
	return a*c;
}
void print(int x){
	char y=x%10+'0';
	if(x>=10)print(x/10);
	putchar(y);
}
int n,m,s,t,v,z,d[30];
double a[505][505],b[30][30];
int main(){
	n=read(),m=read(),s=read()-1,t=read()-1,z=n*n;
	for(int i=0;i<m;i++){
		int x=read()-1,y=read()-1;
		d[x]++,d[y]++,b[x][y]=b[y][x]=1;
	}
	for(int i=0;i<n;i++)
		scanf("%lf",&b[i][i]);
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			if(i!=j)b[i][j]*=(1-b[i][i])/d[i];
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++){
			a[i*n+j][i*n+j]=-1;
			if(i!=j)
				for(int p=0;p<n;p++)
					for(int q=0;q<n;q++)
						a[p*n+q][i*n+j]+=b[i][p]*b[j][q];
		}
	a[s*n+t][z]=-1;
	for(int i=0;i<z;i++){
		for(int j=v=i;j<z;j++)
			if(fabs(a[v][i])<fabs(a[j][i]))v=j;
		for(int j=0;j<=z;j++)
			swap(a[i][j],a[v][j]);
		double u=a[i][i];
		for(int j=0;j<=z;j++)
			a[i][j]/=u;
		for(int j=0;j<z;j++)
			if(u=a[j][i],i!=j)
				for(int k=0;k<=z;k++)
					a[j][k]-=a[i][k]*u;
	}
	for(int i=0;i<n;i++)
		printf("%.7lf ",a[i*n+i][z]);
	return 0;
}


#include <bits/stdc++.h>
#define SZ(x) ((int) (x).size())
#define WRITE(x) (cerr << #x << ' ' << (x) << endl)
using namespace std;

typedef long long i64;
const int NMAX = 25, MMAX = 1005, RMAX = NMAX * NMAX + NMAX;
const double EPS = 1e-10;

double A[RMAX][RMAX];
double aux[RMAX];
double X[RMAX];

int to[MMAX], nextEdge[MMAX], firstEdge[NMAX];
int edges;
int deg[NMAX];

double stay[NMAX];

void addEdge(int x, int y) {
    to[edges] = y;
    nextEdge[edges] = firstEdge[x];
    firstEdge[x] = edges++;
    deg[x]++;
}

void gauss(int n, int m, int r) {
    for (int i = 0, j = 0; i < n && j < m; ) {
        int k;
        for (k = i; k < n && abs(A[k][j]) < EPS; ++k);

        if (k == n) {
            ++j;
            continue;
        }

        {
            memcpy(aux, A[k], sizeof aux);
            memcpy(A[k], A[i], sizeof A[k]);
            memcpy(A[i], aux, sizeof A[i]);
        }

        for (int k = j + 1; k < r; ++k) {
            A[i][k] /= A[i][j];
        }
        A[i][j] = 1;

        for (int k = i + 1; k < n; ++k) {
            for (int p = j + 1; p < r; ++p) {
                A[k][p] -= A[k][j] * A[i][p];
            }
            A[k][j] = 0;
        }

        i++;
        j++;
    }
}

int main() {
    #ifdef LOCAL_RUN
    freopen("task.in", "r", stdin);
    freopen("task.out", "w", stdout);
    //freopen("task.err", "w", stderr);
    #endif // ONLINE_JUDGE
    ios::sync_with_stdio(false);

    cout << setprecision(17) << fixed;

    int n, m, a, b;
    cin >> n >> m >> a >> b;
    a--; b--;

    if (a == b) {
        for (int i = 0; i < n; ++i) {
            cout << (i == a ? 1.0: 0.0) << ' ';
        }
        cout << '\n';
        return 0;
    }

    memset(firstEdge, -1, sizeof firstEdge);
    for (int i = 0; i < m; ++i) {
        int x, y;
        cin >> x >> y;
        x--; y--;
        addEdge(x, y);
        addEdge(y, x);
    }

    for (int i = 0; i < n; ++i)
        cin >> stay[i];

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i == j) continue;
            double s = stay[i] * stay[j];
            A[i * n + j][i * n + j] = 1 - s;
            double s1 = stay[i], s2 = stay[j];
            double m1 = (1 - stay[i]) * (1.0L / deg[i]);
            double m2 = (1 - stay[j]) * (1.0L / deg[j]);
            for (int p1 = firstEdge[i]; p1 != -1; p1 = nextEdge[p1]) {
                int ni = to[p1], nj = j;
                double p = m1 * s2;
                if (ni == nj) {
                    A[i * n + j][n * n + ni] = p;
                } else {
                    A[i * n + j][ni * n + nj] = -p;
                }
            }
            for (int p2 = firstEdge[j]; p2 != -1; p2 = nextEdge[p2]) {
                int ni = i, nj = to[p2];
                double p = s1 * m2;
                if (ni == nj) {
                    A[i * n + j][n * n + ni] = p;
                } else {
                    A[i * n + j][ni * n + nj] = -p;
                }
            }
            for (int p1 = firstEdge[i]; p1 != -1; p1 = nextEdge[p1]) {
                for (int p2 = firstEdge[j]; p2 != -1; p2 = nextEdge[p2]) {
                    int ni = to[p1], nj = to[p2];
                    double p = m1 * m2;
                    if (ni == nj) {
                        A[i * n + j][n * n + ni] = p;
                    } else {
                        A[i * n + j][ni * n + nj] = -p;
                    }
                }
            }
        }
    }
//    cerr << "BEFORE:" << endl;
//    for (int i = 0; i < n * n; ++i) {
//        for (int j = 0; j < n * n + n; ++j) {
//            cerr << A[i][j] << ' ';
//        }
//        cerr << endl;
//    }

    gauss(n * n, n * n, n * n + n);

//    cerr << "AFTER: " << endl;
//    for (int i = 0; i < n * n; ++i) {
//        for (int j = 0; j < n * n + n; ++j) {
//            cerr << A[i][j] << ' ';
//        }
//        cerr << endl;
//    }
    for (int p = 0; p < n; ++p) {
        memset(X, 0, sizeof X);
        for (int i = n * n - 1; i >= 0; --i) {
            int j, l = n * n;
            for (j = 0; j < l && abs(A[i][j]) < EPS; ++j);
            if (j == l) {
                if (abs(A[i][l + p]) > EPS) throw -1337;
                else continue;
            }

            double val = A[i][l + p];
            for (int k = j + 1; k < l; ++k)
                val -= X[k] * A[i][k];
            X[j] = val;
        }
        cout << X[a * n + b] << '\n';
    }
}