import java.io.*;
import java.util.*;

public class Main{

	public static void main(String args[]) throws IOException{
		new Main().mains();
	}

	int m,n,St_a,St_b;
	double M[][],G[][],deg[],ans[];
	public int num(int a, int b){
		return a * m + b - m;
	}
	public void solve() throws IOException{
		m = nextInt();
		n = nextInt();
		St_a = nextInt();
		St_b = nextInt();
		if (St_a == St_b){
			for (int i = 1; i <= m; i ++)
				out.printf("%.8f\n",(i == St_a) ? (1.0) : (0.0));
			return;
		}
		M = new double[30 * 30][30 * 30];
		G = new double[30][30];
		deg =  new double[30];
		ans =  new double[30 * 30];
		for (; (n --) > 0; ){
			int j = nextInt();
			int k = nextInt();
			deg[j] ++; deg[k] ++;
			G[j][k] = G[k][j] = 1.0000;
		}
		for (int i = 1; i <= m; i ++){
			G[i][i] = nextDouble();
			for (int j = 1; j <= m; j ++)
				if (i != j)
					G[i][j] *= ((1.0 - G[i][i]) / deg[i]);
			//M[m * m + 1][num(i, i)] = -1.0000;
		}
		for (int a1 = 1; a1 <= m; a1 ++)
			for (int a2 = 1; a2 <= m; a2 ++){
				M[num(a1, a2)][num(a1, a2)] -= 1.000;
				for (int a3 = 1; a3 <= m; a3 ++)
					for (int a4 = 1; a4 <= m; a4 ++)
						if (a3 != a4)
							M[num(a1, a2)][num(a3, a4)] += G[a3][a1] * G[a4][a2];
			}
		int st = 1;
		M[num(St_a, St_b)][m * m + 1] = 1;
		for (int pick = 1; pick <= m * m; ){
			int find = st;
			for (int i = st + 1; i <= m * m; i ++)
				if (Math.abs(M[i][pick]) > Math.abs(M[find][pick]))
					find = i;
			if (Math.abs(M[find][pick]) < 1e-9){
				pick ++;
				continue;
			}
			for (int i = pick; i <= m * m + 1; i ++){
				double j = M[find][i];
				M[find][i] = M[st][i];
				M[st][i] = j;
			}
			for (int cut = st + 1; cut <= m * m; cut ++){
				double temp = M[cut][pick] / M[st][pick];
				for (int j = pick; j <= m * m + 1; j ++)
					M[cut][j] -= temp * M[st][j];
			}
			st ++; pick ++;
		}
		st --;
		for (int now = m * m; st > 0; st --, now --){
			for (; Math.abs(M[st][now]) < 1e-9; now --);
			for (int i = now + 1; i <= m * m; i ++)
				M[st][m * m + 1] += ans[i] * M[st][i];
			ans[now] = -M[st][m * m + 1] / M[st][now];
		}
		for (int i = 1; i <= m; i ++)
			out.printf("%8f\n", ans[num(i, i)]);
	}

	void mains() throws IOException{
		reader = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(new OutputStreamWriter(System.out));
		tokenizer = null;
		//File fin = new File("a.in");
		//reader = new BufferedReader(new InputStreamReader(new FileInputStream(fin)));
		//out = new PrintWriter("a.out");
		solve();
		reader.close();
		out.flush();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

}


#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <inttypes.h>
#include <iomanip>
#define debug(x) std::cout << #x << " = " << x << std::endl;

typedef int int_t;
typedef long double real_t;
const int_t LARGE = 22;

const real_t EPS = 1e-6;

using std::cin;
using std::endl;
using std::cout;

real_t mat[501][501];
//
bool graph[23][23];
int_t degree[LARGE + 1];
real_t prob[LARGE + 1];
int_t n,m,a,b;
template<class T>
T xabs(T x) {
	if(x<0) return -x;
	return x;
}
int_t encode(int_t a,int_t b) {
//	cout<<"encode "<<a<<" "<<b<<" to "<< n * (a - 1) + b - ((a>b)?(a-1):a)<<endl;
	return n * (a - 1) + b - ((a>b)?(a-1):a);
}
//´Ó×´Ì¬(i,j)×ªÒÆµ½(x,y)µÄ´ú¼Û
real_t cost(int_t i,int_t j ,int_t x,int_t y) {
	real_t result = 0;
	if(i == x && j == y) result = prob[i] * prob[j];
	if(i == x && j != y) {
		result = prob[i] * (1 - prob[j]) * (1.0 / degree[j]) * graph[j][y];
	}
	if(i != x && j == y) result = (1 - prob[i]) * (1.0 / degree[i]) * graph[i][x] * prob[j];
	if(i != x && j != y) result = (1 - prob[i]) * (1.0 / degree[i]) * graph[i][x] * (1 - prob[j]) * (1.0 / degree[j]) * graph[j][y];
//	cout <<"cost "<<i<<" "<<j<<","<<x<<" "<<y<<" = "<<result<<endl;
	return result;
}
void print() {
	for(int_t i = 1 ; i <= n * n; i++) {
		for(int_t j = 1; j <= n * n + n; j++) {
			cout.width(8);
			cout.setf(std::ios::fixed);
			cout <<std::setprecision(3)<< mat[i][j] << " ";
		}
		cout << endl;
	}
}
int main() {
	cin >> n >> m >> a >> b;
	if(a == b) {
		cout << 1 << endl;;
		return 0;
	}
	for(int_t i = 1; i <= m; i++) {
		int_t from,to;
		cin >> from >> to;
		graph[from][to] = graph[to][from] = 1;
		degree[from] += 1;
		degree[to] += 1;
	}
	for(int_t i = 1 ; i <= n; i++) {
		cin >> prob[i];
	}
	int_t len = n * n - n;
	//¹¹ÔìÏµÊý¾ØÕó
	for(int_t i = 1 ; i <= n; i++) {
		for(int_t j = 1; j<= n ; j++) {
			if(i == j) continue;
			int_t curr = encode(i,j);
			mat[curr][curr] = -1;
			//Ã¶¾Ù³ö±ß
			for(int_t x = 1 ; x <= n; x++) {
				for(int_t y = 1; y <= n ; y++) {
					if(x == y) {
						mat[curr][len + x] -= cost(i,j,x,y);
//						printf("from %d %d to %d %d -%lf to %lf\n",i,j,x,y,(double)cost(i,j,x,y),(double)mat[curr][n * n - n + x]);
					} else {
						mat[curr][encode(x,y)] += cost(i,j,x,y);
//						printf("from %d %d to %d %d %lf to %lf\n",i,j,x,y,(double)cost(i,j,x,y),(double)mat[curr][encode(x,y)]);
					}
				}
			}
		}
	}
	//Ã¶¾ÙÖ÷Ôª
	for(int_t i = 1; i <= len; i++) {
		if(xabs(mat[i][i]) < EPS) {
			int_t pos = -1;
			for(int_t j = i + 1; j <= len ; j++) {
				if(xabs(mat[j][i]) >= EPS) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mat[i],mat[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(int_t j = i + 1; j <= len ; j++) {
			real_t f = mat[j][i] / mat[i][i];
			for(int_t k = i ; k <= n * n; k++) {
				mat[j][k] -= f* mat[i][k];
			}
		}
	}
	//»Ø´ú
	for(int_t i = len ; i >=1 ; i--) {
		real_t f = mat[i][i];
		for(int_t j = len + 1; j <= n * n ; j++) {
			mat[i][j] /= f;
		}
		mat[i][i] /= f;
		for(int_t j = i - 1; j >= 1; j--) {
			real_t f2 =  mat[j][i];
			mat[j][i] = 0;
			for(int_t k = len + 1; k<= n * n; k++) {
				mat[j][k] -= f2 * mat[i][k];
			}
		}
	}
//	print();
	for(int_t i = 1; i <= n; i++) {
		cout.setf(std::ios::fixed);
		cout<<std::setprecision(10)<<mat[encode(a,b)][len+i]<<" ";
	}
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <inttypes.h>
#include <iomanip>
#define debug(x) std::cout << #x << " = " << x << std::endl;

typedef int int_t;
typedef long double real_t;
const int_t LARGE = 22;

const real_t EPS = 1e-6;

using std::cin;
using std::endl;
using std::cout;

real_t mat[501][501];

bool graph[23][23];
int_t degree[LARGE + 1];
real_t prob[LARGE + 1];
int_t n,m,a,b;
template<class T>
T xabs(T x) {
	if(x<0) return -x;
	return x;
}
int_t encode(int_t a,int_t b) {
//	cout<<"encode "<<a<<" "<<b<<" to "<< n * (a - 1) + b - ((a>b)?(a-1):a)<<endl;
	return n * (a - 1) + b - ((a>b)?(a-1):a);
}
//´Ó×´Ì¬(i,j)×ªÒÆµ½(x,y)µÄ´ú¼Û
real_t cost(int_t i,int_t j ,int_t x,int_t y) {
	real_t result = 0;
	if(i == x && j == y) result = prob[i] * prob[j];
	if(i == x && j != y) {
		result = prob[i] * (1 - prob[j]) * (1.0 / degree[j]) * graph[j][y];
	}
	if(i != x && j == y) result = (1 - prob[i]) * (1.0 / degree[i]) * graph[i][x] * prob[j];
	if(i != x && j != y) result = (1 - prob[i]) * (1.0 / degree[i]) * graph[i][x] * (1 - prob[j]) * (1.0 / degree[j]) * graph[j][y];
//	cout <<"cost "<<i<<" "<<j<<","<<x<<" "<<y<<" = "<<result<<endl;
	return result;
}
void print() {
	for(int_t i = 1 ; i <= n * n; i++) {
		for(int_t j = 1; j <= n * n + n; j++) {
			cout.width(8);
			cout.setf(std::ios::fixed);
			cout <<std::setprecision(3)<< mat[i][j] << " ";
		}
		cout << endl;
	}
}
int main() {
	cin >> n >> m >> a >> b;
	if(a == b) {
		for(int_t i=1;i<=n;i++){
			if(i==a) cout<<1<<" ";
			else cout<<0<<" ";
		}
		return 0;
	}
	for(int_t i = 1; i <= m; i++) {
		int_t from,to;
		cin >> from >> to;
		graph[from][to] = graph[to][from] = 1;
		degree[from] += 1;
		degree[to] += 1;
	}
	for(int_t i = 1 ; i <= n; i++) {
		cin >> prob[i];
	}
	int_t len = n * n - n;
	//¹¹ÔìÏµÊý¾ØÕó
	for(int_t i = 1 ; i <= n; i++) {
		for(int_t j = 1; j<= n ; j++) {
			if(i == j) continue;
			int_t curr = encode(i,j);
			mat[curr][curr] = -1;
			//Ã¶¾Ù³ö±ß
			for(int_t x = 1 ; x <= n; x++) {
				for(int_t y = 1; y <= n ; y++) {
					if(x == y) {
						mat[curr][len + x] -= cost(i,j,x,y);
//						printf("from %d %d to %d %d -%lf to %lf\n",i,j,x,y,(double)cost(i,j,x,y),(double)mat[curr][n * n - n + x]);
					} else {
						mat[curr][encode(x,y)] += cost(i,j,x,y);
//						printf("from %d %d to %d %d %lf to %lf\n",i,j,x,y,(double)cost(i,j,x,y),(double)mat[curr][encode(x,y)]);
					}
				}
			}
		}
	}
	//Ã¶¾ÙÖ÷Ôª
	for(int_t i = 1; i <= len; i++) {
		if(xabs(mat[i][i]) < EPS) {
			int_t pos = -1;
			for(int_t j = i + 1; j <= len ; j++) {
				if(xabs(mat[j][i]) >= EPS) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mat[i],mat[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(int_t j = i + 1; j <= len ; j++) {
			real_t f = mat[j][i] / mat[i][i];
			for(int_t k = i ; k <= n * n; k++) {
				mat[j][k] -= f* mat[i][k];
			}
		}
	}
	//»Ø´ú
	for(int_t i = len ; i >=1 ; i--) {
		real_t f = mat[i][i];
		for(int_t j = len + 1; j <= n * n ; j++) {
			mat[i][j] /= f;
		}
		mat[i][i] /= f;
		for(int_t j = i - 1; j >= 1; j--) {
			real_t f2 =  mat[j][i];
			mat[j][i] = 0;
			for(int_t k = len + 1; k<= n * n; k++) {
				mat[j][k] -= f2 * mat[i][k];
			}
		}
	}
//	print();
	for(int_t i = 1; i <= n; i++) {
		cout.setf(std::ios::fixed);
		cout<<std::setprecision(10)<<mat[encode(a,b)][len+i]<<" ";
	}
	return 0;
}


#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <inttypes.h>
#include <iomanip>
#define debug(x) std::cout << #x << " = " << x << std::endl;

typedef int int_t;
typedef long double real_t;
const int_t LARGE = 22;

const real_t EPS = 1e-6;

using std::cin;
using std::endl;
using std::cout;

real_t mat[501][501];

bool graph[23][23];
int_t degree[LARGE + 1];
real_t prob[LARGE + 1];
int_t n,m,a,b;
template<class T>
T xabs(T x) {
	if(x<0) return -x;
	return x;
}
int_t encode(int_t a,int_t b) {
//	cout<<"encode "<<a<<" "<<b<<" to "<< n * (a - 1) + b - ((a>b)?(a-1):a)<<endl;
	return n * (a - 1) + b - ((a>b)?(a-1):a);
}
//´Ó×´Ì¬(i,j)×ªÒÆµ½(x,y)µÄ´ú¼Û
real_t cost(int_t i,int_t j ,int_t x,int_t y) {
	real_t result = 0;
	if(i == x && j == y) result = prob[i] * prob[j];
	if(i == x && j != y) {
		result = prob[i] * (1 - prob[j]) * (1.0 / degree[j]) * graph[j][y];
	}
	if(i != x && j == y) result = (1 - prob[i]) * (1.0 / degree[i]) * graph[i][x] * prob[j];
	if(i != x && j != y) result = (1 - prob[i]) * (1.0 / degree[i]) * graph[i][x] * (1 - prob[j]) * (1.0 / degree[j]) * graph[j][y];
//	cout <<"cost "<<i<<" "<<j<<","<<x<<" "<<y<<" = "<<result<<endl;
	return result;
}
void print() {
	for(int_t i = 1 ; i <= n * n; i++) {
		for(int_t j = 1; j <= n * n + n; j++) {
			cout.width(8);
			cout.setf(std::ios::fixed);
			cout <<std::setprecision(3)<< mat[i][j] << " ";
		}
		cout << endl;
	}
}
int main() {
	cin >> n >> m >> a >> b;
	if(a == b) {
		cout << 1 << endl;;
		return 0;
	}
	for(int_t i = 1; i <= m; i++) {
		int_t from,to;
		cin >> from >> to;
		graph[from][to] = graph[to][from] = 1;
		degree[from] += 1;
		degree[to] += 1;
	}
	for(int_t i = 1 ; i <= n; i++) {
		cin >> prob[i];
	}
	int_t len = n * n - n;
	//¹¹ÔìÏµÊý¾ØÕó
	for(int_t i = 1 ; i <= n; i++) {
		for(int_t j = 1; j<= n ; j++) {
			if(i == j) continue;
			int_t curr = encode(i,j);
			mat[curr][curr] = -1;
			//Ã¶¾Ù³ö±ß
			for(int_t x = 1 ; x <= n; x++) {
				for(int_t y = 1; y <= n ; y++) {
					if(x == y) {
						mat[curr][len + x] -= cost(i,j,x,y);
//						printf("from %d %d to %d %d -%lf to %lf\n",i,j,x,y,(double)cost(i,j,x,y),(double)mat[curr][n * n - n + x]);
					} else {
						mat[curr][encode(x,y)] += cost(i,j,x,y);
//						printf("from %d %d to %d %d %lf to %lf\n",i,j,x,y,(double)cost(i,j,x,y),(double)mat[curr][encode(x,y)]);
					}
				}
			}
		}
	}
	//Ã¶¾ÙÖ÷Ôª
	for(int_t i = 1; i <= len; i++) {
		if(xabs(mat[i][i]) < EPS) {
			int_t pos = -1;
			for(int_t j = i + 1; j <= len ; j++) {
				if(xabs(mat[j][i]) >= EPS) {
					pos = j;
					break;
				}
			}
			if(pos != -1) {
				std::swap(mat[i],mat[pos]);
			} else {
				cout <<" exm ?? "<< endl;
				return 0;
			}
		}
		for(int_t j = i + 1; j <= len ; j++) {
			real_t f = mat[j][i] / mat[i][i];
			for(int_t k = i ; k <= n * n; k++) {
				mat[j][k] -= f* mat[i][k];
			}
		}
	}
	//»Ø´ú
	for(int_t i = len ; i >=1 ; i--) {
		real_t f = mat[i][i];
		for(int_t j = len + 1; j <= n * n ; j++) {
			mat[i][j] /= f;
		}
		mat[i][i] /= f;
		for(int_t j = i - 1; j >= 1; j--) {
			real_t f2 =  mat[j][i];
			mat[j][i] = 0;
			for(int_t k = len + 1; k<= n * n; k++) {
				mat[j][k] -= f2 * mat[i][k];
			}
		}
	}
//	print();
	for(int_t i = 1; i <= n; i++) {
		cout.setf(std::ios::fixed);
		cout<<std::setprecision(10)<<mat[encode(a,b)][len+i]<<" ";
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int N = 22 + 1, M = 22 * 22 + 2;
const double eps = 1e-6;
int n, m, sx, sy;
double p[N], a[M][M], ans[M];
vector<int> g[N];
inline int Mp(int x, int y) { return (x - 1) * n + y; }
inline void Gause(double a[M][M], int n, double *ans) {
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			if (abs(a[i][i]) < eps) {
				for (int k = i; k <= n + 1; ++k) swap(a[i][k], a[j][k]);
			} else {
				double ratio = a[j][i] / a[i][i];
				for (int k = i; k <= n + 1; ++k) a[j][k] -= a[i][k] * ratio;
			}
	for (int i = n; i; --i) {
		for (int j = i + 1; j <= n; ++j) a[i][n + 1] -= a[i][j] * ans[j];
		ans[i] = a[i][n + 1] / a[i][i];
	}
}
int main() {
	scanf("%d%d%d%d", &n, &m, &sx, &sy);
	for (int i = 1, x, y; i <= m; ++i) {
		scanf("%d%d", &x, &y);
		g[x].push_back(y);
		g[y].push_back(x);
	}
	for (int i = 1; i <= n; ++i) g[i].push_back(i);
	for (int i = 1; i <= n; ++i) scanf("%lf", p + i);
	for (int ux = 1; ux <= n; ++ux)
		for (int uy = 1; uy <= n; ++uy) if (ux != uy)
			for (int vx:g[ux])
				for (int vy:g[uy]) {
					double xpr = (ux == vx ? p[ux] : (1 - p[ux]) / (g[ux].size() - 1));
					double ypr = (uy == vy ? p[uy] : (1 - p[uy]) / (g[uy].size() - 1));
					a[Mp(vx, vy)][Mp(ux, uy)] = xpr * ypr;
				}
	for (int i = 1; i <= n * n; ++i) a[i][i] -= 1;
	a[Mp(sx, sy)][n * n + 1] = -1;
	Gause(a, n * n, ans);
	for (int i = 1; i <= n; ++i) printf("%.10lf ", ans[Mp(i, i)]);
	return 0;
}


#include<cstdio>
#include<iostream>
using namespace std;
const int maxn=1111;
const double eps=1e-8;
int N,M,tot,fir[maxn],to[maxn],nxt[maxn],D[maxn];
double A[maxn][maxn],p[maxn],q[maxn];
double fabs(double x)
{
	if(x<eps&&x>-eps) return 0;
	return x<0?-x:x;//这个fabs可以处理-0.0000000000000000 -> 待修改
}
void gaosixiaoyuan()
{
	int n=N,m=M;N*=N,M=N<<1;
	/*puts("");for(int i=1;i<=N;++i)
	{
		for(int j=1;j<=M;++j)
		{
			int op=A[i][j];
			printf("%d ",op);
		}puts("");
	}*/
	for(int i=1;i<=N;++i)
	{
		int r=i;
		for(int j=i+1;j<=N;++j)if(fabs(A[j][i])>fabs(A[r][i])) r=j;
		swap(A[i],A[r]);
		double u=A[i][i];
		for(int j=i;j<=M;++j) A[i][j]/=u;
		for(int j=1;j<=N;++j)if(j!=i)
		{
			u=A[j][i];
			for(int k=i;k<=M;++k)
			{
				A[j][k]-=u*A[i][k];
			}
		}
	}
	N=n,M=m;
}
void add_edge(int x,int y)
{
	nxt[++tot]=fir[x],to[fir[x]=tot]=y;
}
int main()
{
	int n,m;scanf("%d%d%d%d",&N,&M,&n,&m);n=(n-1)*N+m;
	for(int i=1;i<=M;++i)
	{
		int a,b;scanf("%d%d",&a,&b);
		add_edge(a,b),add_edge(b,a);
		++D[a],++D[b];
	}
	for(int i=1;i<=N;++i)
	{
		scanf("%lf",p+i);
		q[i]=(1-p[i])/D[i];
	}
	for(int i=1;i<=N;++i)for(int j=1;j<=N;++j)if(i!=j)
	{
		int id=(i-1)*N+j;
		for(int a=fir[i];a;a=nxt[a])for(int b=fir[j];b;b=nxt[b])
		{
			int x=to[a],y=to[b],idd=(x-1)*N+y;
			A[id][idd]=q[i]*q[j];
		}
		for(int k=fir[i],v=to[k];k;k=nxt[k],v=to[k])
		{
			A[id][(v-1)*N+j]=q[i]*p[j];
		}
		for(int k=fir[j],v=to[k];k;k=nxt[k],v=to[k])
		{
			A[id][(i-1)*N+v]=p[i]*q[j];
		}
		A[id][id]=p[i]*p[j]-1;
	}
	for(int i=1;i<=N;++i)
	{
		int id=(i-1)*N+i;
		A[id][id]=A[id][N*N+i]=1;
	}
	gaosixiaoyuan();
	for(int i=1;i<=N;++i)
	{
		if(fabs(A[n][N*N+i])<eps) printf("0.0000000000 ");//因为都是正的
		else printf("%.10f ",A[n][N*N+i]);
	}
	return 0;
}


#include<cstdio>
#include<iostream>
using namespace std;
const int maxn=1111;
const double eps=1e-8;
int N,M,tot,fir[maxn],to[maxn],nxt[maxn],D[maxn];
double A[maxn][maxn],p[maxn],q[maxn];
double fabs(double x)
{
	return x<0?-x:x;//这个fabs不能处理-0.0000000000000000 -> 待修改
}
void gaosixiaoyuan()
{
	int n=N,m=M;N*=N,M=N<<1;
	/*puts("");for(int i=1;i<=N;++i)
	{
		for(int j=1;j<=M;++j)
		{
			int op=A[i][j];
			printf("%d ",op);
		}puts("");
	}*/
	for(int i=1;i<=N;++i)
	{
		int r=i;
		for(int j=i+1;j<=N;++j)if(fabs(A[j][i])>fabs(A[r][i])) r=j;
		swap(A[i],A[r]);
		double u=A[i][i];
		for(int j=i;j<=M;++j) A[i][j]/=u;
		for(int j=1;j<=N;++j)if(j!=i)
		{
			u=A[j][i];
			for(int k=i;k<=M;++k)
			{
				A[j][k]-=u*A[i][k];
			}
		}
	}
	N=n,M=m;
}
void add_edge(int x,int y)
{
	nxt[++tot]=fir[x],to[fir[x]=tot]=y;
}
int main()
{
	int n,m;scanf("%d%d%d%d",&N,&M,&n,&m);n=(n-1)*N+m;
	for(int i=1;i<=M;++i)
	{
		int a,b;scanf("%d%d",&a,&b);
		add_edge(a,b),add_edge(b,a);
		++D[a],++D[b];
	}
	for(int i=1;i<=N;++i)
	{
		scanf("%lf",p+i);
		q[i]=(1-p[i])/D[i];
	}
	for(int i=1;i<=N;++i)for(int j=1;j<=N;++j)if(i!=j)
	{
		int id=(i-1)*N+j;
		for(int a=fir[i];a;a=nxt[a])for(int b=fir[j];b;b=nxt[b])
		{
			int x=to[a],y=to[b],idd=(x-1)*N+y;
			A[id][idd]=q[i]*q[j];
		}
		for(int k=fir[i],v=to[k];k;k=nxt[k],v=to[k])
		{
			A[id][(v-1)*N+j]=q[i]*p[j];
		}
		for(int k=fir[j],v=to[k];k;k=nxt[k],v=to[k])
		{
			A[id][(i-1)*N+v]=p[i]*q[j];
		}
		A[id][id]=p[i]*p[j]-1;
	}
	for(int i=1;i<=N;++i)
	{
		int id=(i-1)*N+i;
		A[id][id]=A[id][N*N+i]=1;
	}
	gaosixiaoyuan();
	for(int i=1;i<=N;++i)
	{
		if(A[n][N*N+i]<eps) printf("0.0000000000 ");//因为都是正的
		else printf("%.10f ",A[n][N*N+i]);
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
inline int read()
{
	int x = 0, f = 1; char ch = getchar();
	while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
#define get(x, y) (x) > (y) ? id[y][x] : id[x][y]
const int N = 24;
const int INF = 1e9;
int tot, id[N][N];
bool b[N][N];
int d[N];
double a[N*N][N*N], p[N];
inline void add(int q,int w,int e,int r)
{
    b[get(q, w)][get(e, r)] = 1;
    b[get(e, r)][get(q, w)] = 1;
}
void gauss()
{
    for(int i = 1; i <= tot; i ++)
    {
        for(int k = i + 1; k <= tot; k ++)
        	if(abs(a[k][i]) > abs(a[i][i]))swap(a[k],a[i]);
        for(int j = tot + 1; j >= i; j --)
        	a[i][j] /= a[i][i];
        for(int k = i + 1; k <= tot; k ++)
            for(int j = tot + 1; j >= i; j --)
            	a[k][j] -= a[k][i] * a[i][j];
    }
    for(int i = tot; i; i --)
        for(int k = i - 1; k; k --)
        	a[k][tot + 1] -= a[k][i] * a[i][tot + 1];
}
int main()
{
    int n = read();
    int m = read();
    int x = read();
    int y = read();
    for(int i = 1; i <= m; i ++)
    {
        int x = read();
        int y = read();
        b[x][y] = b[y][x] = 1;
        d[x] ++;
        d[y] ++;
    }
    for(int i = 1; i <= n; i ++) cin >> p[i];
    for(int i = 1; i <= n; i ++)
        for(int j = i; j <= n; j ++)
        	id[i][j] = ++ tot;
    for(int o = 1; o <= n; o ++)
    {
        memset(a,0,sizeof(a));
        a[get(o,o)][tot + 1] = 1;
        for(int i = 1; i <= n; i ++)
        {
            a[get(i,i)][get(i,i)] = 1;
            for(int j = i + 1; j <= n; j ++)
            {
                int now = get(i, j);
                a[now][now] = p[i] * p[j] - 1;
                for(int k = 1; k <= n ; k ++)
                	a[now][get(i,k)] += b[j][k] * p[i] * (1 - p[j]) / d[j];
                for(int k = 1; k <= n; k ++)
                	a[now][get(k,j)] += b[i][k] * p[j] * (1 - p[i]) / d[i];
                for(int k = 1; k <= n; k ++)
                    for(int l = 1; l <= n; l ++)
                        a[now][get(k,l)] += b[i][k] * b[j][l] * (1 - p[i]) * (1 - p[j]) / d[i] / d[j];
            }
        }
        gauss();
        printf("%.6lf ",a[get(x,y)][tot+1]);
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
inline int read()
{
	int x = 0, f = 1; char ch = getchar();
	while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
#define get(x, y) (x) > (y) ? id[y][x] : id[x][y]
const int N = 24;
const int INF = 1e9;
int tot, id[N][N];
bool b[N][N];
int d[N];
double a[N*N][N*N], p[N];
inline void add(int q,int w,int e,int r)
{
    b[get(q, w)][get(e, r)] = 1;
    b[get(e, r)][get(q, w)] = 1;
}
void gauss()
{
    for(int i = 1; i <= tot; i ++)
    {
        for(int k = i + 1; k <= tot; k ++)
        	if(abs(a[k][i]) > abs(a[i][i]))swap(a[k],a[i]);
        for(int j = tot + 1; j >= i; j --)
        	a[i][j] /= a[i][i];
        for(int k = i + 1; k <= tot; k ++)
            for(int j = tot + 1; j >= i; j --)
            	a[k][j] -= a[k][i] * a[i][j];
    }
    for(int i = tot; i; i --)
        for(int k = i - 1; k; k --)
        	a[k][tot + 1] -= a[k][i] * a[i][tot + 1];
}
int main()
{
    int n = read();
    int m = read();
    int x = read();
    int y = read();
    for(int i = 1; i <= m; i ++)
    {
        x = read();
        y = read();
        b[x][y] = b[y][x] = 1;
        d[x] ++;
        d[y] ++;
    }
    for(int i = 1; i <= n; i ++)
    	scanf("%lf", &p[i]);
    for(int i = 1; i <= n; i ++)
        for(int j = i; j <= n; j ++)
        	id[i][j] = ++ tot;
    for(int o = 1; o <= n; o ++)
    {
        memset(a,0,sizeof(a));
        a[get(o,o)][tot + 1] = 1;
        for(int i = 1; i <= n; i ++)
        {
            a[get(i,i)][get(i,i)] = 1;
            for(int j = i + 1; j <= n; j ++)
            {
                int now = get(i, j);
                a[now][now] = p[i] * p[j] - 1;
                for(int k = 1; k <= n ; k ++)
                	a[now][get(i,k)] += b[j][k] * p[i] * (1 - p[j]) / d[j];
                for(int k = 1; k <= n; k ++)
                	a[now][get(k,j)] += b[i][k] * p[j] * (1 - p[i]) / d[i];
                for(int k = 1; k <= n; k ++)
                    for(int l = 1; l <= n; l ++)
                        a[now][get(k,l)] += b[i][k] * b[j][l] * (1 - p[i]) * (1 - p[j]) / d[i] / d[j];
            }
        }
        gauss();
        printf("%.6lf ",a[get(x,y)][tot+1]);
    }
    return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <assert.h>

#ifndef ONLINE_JUDGE
	#define ASSERT assert
#else
	#define ASSERT(p)
#endif

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

template<typename T>
class Strassen_class{
public:
      void ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );//朴素算法实现
      void FillMatrix( T** MatrixA, T** MatrixB, int length);//A,B矩阵赋值
      void PrintMatrix(T **MatrixA,int MatrixSize);//打印矩阵
      void Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC);//Strassen算法实现
};
template<typename T>
void Strassen_class<T>::ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
        for (int j=0;j<MatrixSize ;j++)
        {
            MatrixResult[i][j]=0;
            for (int k=0;k<MatrixSize ;k++)
            {
                MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
            }
        }
    }
}

/*
c++使用二维数组，申请动态内存方法
申请
int **A;
A = new int *[desired_array_row];
for ( int i = 0; i < desired_array_row; i++)
     A[i] = new int [desired_column_size];

释放
for ( int i = 0; i < your_array_row; i++)
    delete [] A[i];
delete[] A;

*/
template<typename T>
void Strassen_class<T>::Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC)
{

    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 64 )    //分治门槛，小于这个值时不再进行递归计算，而是采用常规矩阵计算方法
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
        T** A11;
        T** A12;
        T** A21;
        T** A22;

        T** B11;
        T** B12;
        T** B21;
        T** B22;

        T** C11;
        T** C12;
        T** C21;
        T** C22;

        T** M1;
        T** M2;
        T** M3;
        T** M4;
        T** M5;
        T** M6;
        T** M7;
        T** AResult;
        T** BResult;

        //making a 1 diminsional pointer based array.
        A11 = new T *[newSize];
        A12 = new T *[newSize];
        A21 = new T *[newSize];
        A22 = new T *[newSize];

        B11 = new T *[newSize];
        B12 = new T *[newSize];
        B21 = new T *[newSize];
        B22 = new T *[newSize];

        C11 = new T *[newSize];
        C12 = new T *[newSize];
        C21 = new T *[newSize];
        C22 = new T *[newSize];

        M1 = new T *[newSize];
        M2 = new T *[newSize];
        M3 = new T *[newSize];
        M4 = new T *[newSize];
        M5 = new T *[newSize];
        M6 = new T *[newSize];
        M7 = new T *[newSize];

        AResult = new T *[newSize];
        BResult = new T *[newSize];

        int newLength = newSize;

        //making that 1 diminsional pointer based array , a 2D pointer based array
        for ( int i = 0; i < newSize; i++)
        {
            A11[i] = new T[newLength];
            A12[i] = new T[newLength];
            A21[i] = new T[newLength];
            A22[i] = new T[newLength];

            B11[i] = new T[newLength];
            B12[i] = new T[newLength];
            B21[i] = new T[newLength];
            B22[i] = new T[newLength];

            C11[i] = new T[newLength];
            C12[i] = new T[newLength];
            C21[i] = new T[newLength];
            C22[i] = new T[newLength];

            M1[i] = new T[newLength];
            M2[i] = new T[newLength];
            M3[i] = new T[newLength];
            M4[i] = new T[newLength];
            M5[i] = new T[newLength];
            M6[i] = new T[newLength];
            M7[i] = new T[newLength];

            AResult[i] = new T[newLength];
            BResult[i] = new T[newLength];

        }
        //splitting input Matrixes, into 4 submatrices each.
        for (int i = 0; i < N / 2; i++)
        {
            for (int j = 0; j < N / 2; j++)
            {
                A11[i][j] = MatrixA[i][j];
                A12[i][j] = MatrixA[i][j + N / 2];
                A21[i][j] = MatrixA[i + N / 2][j];
                A22[i][j] = MatrixA[i + N / 2][j + N / 2];

                B11[i][j] = MatrixB[i][j];
                B12[i][j] = MatrixB[i][j + N / 2];
                B21[i][j] = MatrixB[i + N / 2][j];
                B22[i][j] = MatrixB[i + N / 2][j + N / 2];

            }
        }

        //here we calculate M1..M7 matrices .
        //M1[][]
        ADD( A11,A22,AResult, HalfSize);
        ADD( B11,B22,BResult, HalfSize);                //p5=(a+d)*(e+h)
        Strassen( HalfSize, AResult, BResult, M1 ); //now that we need to multiply this , we use the strassen itself .

        //M2[][]
        ADD( A21,A22,AResult, HalfSize);              //M2=(A21+A22)B11   p3=(c+d)*e
        Strassen(HalfSize, AResult, B11, M2);       //Mul(AResult,B11,M2);

        //M3[][]
        SUB( B12,B22,BResult, HalfSize);              //M3=A11(B12-B22)   p1=a*(f-h)
        Strassen(HalfSize, A11, BResult, M3);       //Mul(A11,BResult,M3);

        //M4[][]
        SUB( B21, B11, BResult, HalfSize);           //M4=A22(B21-B11)    p4=d*(g-e)
        Strassen(HalfSize, A22, BResult, M4);       //Mul(A22,BResult,M4);

        //M5[][]
        ADD( A11, A12, AResult, HalfSize);           //M5=(A11+A12)B22   p2=(a+b)*h
        Strassen(HalfSize, AResult, B22, M5);       //Mul(AResult,B22,M5);

        //M6[][]
        SUB( A21, A11, AResult, HalfSize);
        ADD( B11, B12, BResult, HalfSize);             //M6=(A21-A11)(B11+B12)   p7=(c-a)(e+f)
        Strassen( HalfSize, AResult, BResult, M6);    //Mul(AResult,BResult,M6);

        //M7[][]
        SUB(A12, A22, AResult, HalfSize);
        ADD(B21, B22, BResult, HalfSize);             //M7=(A12-A22)(B21+B22)    p6=(b-d)*(g+h)
        Strassen(HalfSize, AResult, BResult, M7);     //Mul(AResult,BResult,M7);

        //C11 = M1 + M4 - M5 + M7;
        ADD( M1, M4, AResult, HalfSize);
        SUB( M7, M5, BResult, HalfSize);
        ADD( AResult, BResult, C11, HalfSize);

        //C12 = M3 + M5;
        ADD( M3, M5, C12, HalfSize);

        //C21 = M2 + M4;
        ADD( M2, M4, C21, HalfSize);

        //C22 = M1 + M3 - M2 + M6;
        ADD( M1, M3, AResult, HalfSize);
        SUB( M6, M2, BResult, HalfSize);
        ADD( AResult, BResult, C22, HalfSize);

        //at this point , we have calculated the c11..c22 matrices, and now we are going to
        //put them together and make a unit matrix which would describe our resulting Matrix.
        //组合小矩阵到一个大矩阵
        for (int i = 0; i < N/2 ; i++)
        {
            for (int j = 0 ; j < N/2 ; j++)
            {
                MatrixC[i][j] = C11[i][j];
                MatrixC[i][j + N / 2] = C12[i][j];
                MatrixC[i + N / 2][j] = C21[i][j];
                MatrixC[i + N / 2][j + N / 2] = C22[i][j];
            }
        }

        // 释放矩阵内存空间
        for (int i = 0; i < newLength; i++)
        {
            delete[] A11[i];delete[] A12[i];delete[] A21[i];
            delete[] A22[i];

            delete[] B11[i];delete[] B12[i];delete[] B21[i];
            delete[] B22[i];
            delete[] C11[i];delete[] C12[i];delete[] C21[i];
            delete[] C22[i];
            delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
            delete[] M5[i];delete[] M6[i];delete[] M7[i];
            delete[] AResult[i];delete[] BResult[i] ;
        }
        delete[] A11;delete[] A12;delete[] A21;delete[] A22;
        delete[] B11;delete[] B12;delete[] B21;delete[] B22;
        delete[] C11;delete[] C12;delete[] C21;delete[] C22;
        delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
        delete[] M6;delete[] M7;
        delete[] AResult;
        delete[] BResult ;

    }//end of else

}

template<typename T>
void Strassen_class<T>::FillMatrix( T** MatrixA, T** MatrixB, int length)
{
    for(int row = 0; row<length; row++)
    {
        for(int column = 0; column<length; column++)
        {

            MatrixB[row][column] = (MatrixA[row][column] = rand() %5);
            //matrix2[row][column] = rand() % 2;//ba hazfe in khat 50% afzayeshe soorat khahim dasht
        }

    }
}
template<typename T>
void Strassen_class<T>::PrintMatrix(T **MatrixA,int MatrixSize)
{
    cout<<endl;
    for(int row = 0; row<MatrixSize; row++)
    {
        for(int column = 0; column<MatrixSize; column++)
        {

            cout<<MatrixA[row][column]<<"\t";
            if ((column+1)%((MatrixSize)) == 0)
                cout<<endl;
        }

    }
    cout<<endl;
}

struct Matrix
{
	Matrix(int nn)
	{
		ASSERT(nn < 256);
		n = nn;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = 0;
			}
		}
	}

	Matrix(const Matrix &other)
	{
		ASSERT(other.n < 256);
		n = other.n;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = other.a[i][j];
			}
		}
	}

	void unit()
	{

		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	/*
	Matrix operator*(const Matrix &other) const
	{
		ASSERT(n < 256 && other.n < 256);
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}*/

	Matrix operator*(const Matrix &other) const
	{
		Matrix res(n);
		Strassen_class<double> stra;
		stra.Strassen(n, a, other.a, res.a);

		return res;
	}

	Matrix calPow(int k) const
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	double* operator[](int i)
	{
		ASSERT(i < 256);
		return a[i];
	}

	void print() const
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}

	int n;
private:
	//vector<vector<double> > a;
	double **a;
};

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	Matrix mat(stateNum);
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	//mat.print();
	Matrix tranMat = mat.calPow(100000);
	//Matrix tranMat(mat.power((int)1e6));
	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <assert.h>

#ifndef ONLINE_JUDGE
	#define ASSERT assert
#else
	#define ASSERT(p)
#endif

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

template<typename T>
class Strassen_class{
public:
      void ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );//朴素算法实现
      void FillMatrix( T** MatrixA, T** MatrixB, int length);//A,B矩阵赋值
      void PrintMatrix(T **MatrixA,int MatrixSize);//打印矩阵
      void Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC);//Strassen算法实现
};
template<typename T>
void Strassen_class<T>::ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
        for (int j=0;j<MatrixSize ;j++)
        {
            MatrixResult[i][j]=0;
            for (int k=0;k<MatrixSize ;k++)
            {
                MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
            }
        }
    }
}

/*
c++使用二维数组，申请动态内存方法
申请
int **A;
A = new int *[desired_array_row];
for ( int i = 0; i < desired_array_row; i++)
     A[i] = new int [desired_column_size];

释放
for ( int i = 0; i < your_array_row; i++)
    delete [] A[i];
delete[] A;

*/
template<typename T>
void Strassen_class<T>::Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC)
{

    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 64 )    //分治门槛，小于这个值时不再进行递归计算，而是采用常规矩阵计算方法
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
        T** A11;
        T** A12;
        T** A21;
        T** A22;

        T** B11;
        T** B12;
        T** B21;
        T** B22;

        T** C11;
        T** C12;
        T** C21;
        T** C22;

        T** M1;
        T** M2;
        T** M3;
        T** M4;
        T** M5;
        T** M6;
        T** M7;
        T** AResult;
        T** BResult;

        //making a 1 diminsional pointer based array.
        A11 = new T *[newSize];
        A12 = new T *[newSize];
        A21 = new T *[newSize];
        A22 = new T *[newSize];

        B11 = new T *[newSize];
        B12 = new T *[newSize];
        B21 = new T *[newSize];
        B22 = new T *[newSize];

        C11 = new T *[newSize];
        C12 = new T *[newSize];
        C21 = new T *[newSize];
        C22 = new T *[newSize];

        M1 = new T *[newSize];
        M2 = new T *[newSize];
        M3 = new T *[newSize];
        M4 = new T *[newSize];
        M5 = new T *[newSize];
        M6 = new T *[newSize];
        M7 = new T *[newSize];

        AResult = new T *[newSize];
        BResult = new T *[newSize];

        int newLength = newSize;

        //making that 1 diminsional pointer based array , a 2D pointer based array
        for ( int i = 0; i < newSize; i++)
        {
            A11[i] = new T[newLength];
            A12[i] = new T[newLength];
            A21[i] = new T[newLength];
            A22[i] = new T[newLength];

            B11[i] = new T[newLength];
            B12[i] = new T[newLength];
            B21[i] = new T[newLength];
            B22[i] = new T[newLength];

            C11[i] = new T[newLength];
            C12[i] = new T[newLength];
            C21[i] = new T[newLength];
            C22[i] = new T[newLength];

            M1[i] = new T[newLength];
            M2[i] = new T[newLength];
            M3[i] = new T[newLength];
            M4[i] = new T[newLength];
            M5[i] = new T[newLength];
            M6[i] = new T[newLength];
            M7[i] = new T[newLength];

            AResult[i] = new T[newLength];
            BResult[i] = new T[newLength];

        }
        //splitting input Matrixes, into 4 submatrices each.
        for (int i = 0; i < N / 2; i++)
        {
            for (int j = 0; j < N / 2; j++)
            {
                A11[i][j] = MatrixA[i][j];
                A12[i][j] = MatrixA[i][j + N / 2];
                A21[i][j] = MatrixA[i + N / 2][j];
                A22[i][j] = MatrixA[i + N / 2][j + N / 2];

                B11[i][j] = MatrixB[i][j];
                B12[i][j] = MatrixB[i][j + N / 2];
                B21[i][j] = MatrixB[i + N / 2][j];
                B22[i][j] = MatrixB[i + N / 2][j + N / 2];

            }
        }

        //here we calculate M1..M7 matrices .
        //M1[][]
        ADD( A11,A22,AResult, HalfSize);
        ADD( B11,B22,BResult, HalfSize);                //p5=(a+d)*(e+h)
        Strassen( HalfSize, AResult, BResult, M1 ); //now that we need to multiply this , we use the strassen itself .

        //M2[][]
        ADD( A21,A22,AResult, HalfSize);              //M2=(A21+A22)B11   p3=(c+d)*e
        Strassen(HalfSize, AResult, B11, M2);       //Mul(AResult,B11,M2);

        //M3[][]
        SUB( B12,B22,BResult, HalfSize);              //M3=A11(B12-B22)   p1=a*(f-h)
        Strassen(HalfSize, A11, BResult, M3);       //Mul(A11,BResult,M3);

        //M4[][]
        SUB( B21, B11, BResult, HalfSize);           //M4=A22(B21-B11)    p4=d*(g-e)
        Strassen(HalfSize, A22, BResult, M4);       //Mul(A22,BResult,M4);

        //M5[][]
        ADD( A11, A12, AResult, HalfSize);           //M5=(A11+A12)B22   p2=(a+b)*h
        Strassen(HalfSize, AResult, B22, M5);       //Mul(AResult,B22,M5);

        //M6[][]
        SUB( A21, A11, AResult, HalfSize);
        ADD( B11, B12, BResult, HalfSize);             //M6=(A21-A11)(B11+B12)   p7=(c-a)(e+f)
        Strassen( HalfSize, AResult, BResult, M6);    //Mul(AResult,BResult,M6);

        //M7[][]
        SUB(A12, A22, AResult, HalfSize);
        ADD(B21, B22, BResult, HalfSize);             //M7=(A12-A22)(B21+B22)    p6=(b-d)*(g+h)
        Strassen(HalfSize, AResult, BResult, M7);     //Mul(AResult,BResult,M7);

        //C11 = M1 + M4 - M5 + M7;
        ADD( M1, M4, AResult, HalfSize);
        SUB( M7, M5, BResult, HalfSize);
        ADD( AResult, BResult, C11, HalfSize);

        //C12 = M3 + M5;
        ADD( M3, M5, C12, HalfSize);

        //C21 = M2 + M4;
        ADD( M2, M4, C21, HalfSize);

        //C22 = M1 + M3 - M2 + M6;
        ADD( M1, M3, AResult, HalfSize);
        SUB( M6, M2, BResult, HalfSize);
        ADD( AResult, BResult, C22, HalfSize);

        //at this point , we have calculated the c11..c22 matrices, and now we are going to
        //put them together and make a unit matrix which would describe our resulting Matrix.
        //组合小矩阵到一个大矩阵
        for (int i = 0; i < N/2 ; i++)
        {
            for (int j = 0 ; j < N/2 ; j++)
            {
                MatrixC[i][j] = C11[i][j];
                MatrixC[i][j + N / 2] = C12[i][j];
                MatrixC[i + N / 2][j] = C21[i][j];
                MatrixC[i + N / 2][j + N / 2] = C22[i][j];
            }
        }

        // 释放矩阵内存空间
        for (int i = 0; i < newLength; i++)
        {
            delete[] A11[i];delete[] A12[i];delete[] A21[i];
            delete[] A22[i];

            delete[] B11[i];delete[] B12[i];delete[] B21[i];
            delete[] B22[i];
            delete[] C11[i];delete[] C12[i];delete[] C21[i];
            delete[] C22[i];
            delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
            delete[] M5[i];delete[] M6[i];delete[] M7[i];
            delete[] AResult[i];delete[] BResult[i] ;
        }
        delete[] A11;delete[] A12;delete[] A21;delete[] A22;
        delete[] B11;delete[] B12;delete[] B21;delete[] B22;
        delete[] C11;delete[] C12;delete[] C21;delete[] C22;
        delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
        delete[] M6;delete[] M7;
        delete[] AResult;
        delete[] BResult ;

    }//end of else

}

template<typename T>
void Strassen_class<T>::FillMatrix( T** MatrixA, T** MatrixB, int length)
{
    for(int row = 0; row<length; row++)
    {
        for(int column = 0; column<length; column++)
        {

            MatrixB[row][column] = (MatrixA[row][column] = rand() %5);
            //matrix2[row][column] = rand() % 2;//ba hazfe in khat 50% afzayeshe soorat khahim dasht
        }

    }
}
template<typename T>
void Strassen_class<T>::PrintMatrix(T **MatrixA,int MatrixSize)
{
    cout<<endl;
    for(int row = 0; row<MatrixSize; row++)
    {
        for(int column = 0; column<MatrixSize; column++)
        {

            cout<<MatrixA[row][column]<<"\t";
            if ((column+1)%((MatrixSize)) == 0)
                cout<<endl;
        }

    }
    cout<<endl;
}

struct Matrix
{
	Matrix(int nn)
	{
		ASSERT(nn < 256);
		n = nn;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = 0;
			}
		}
	}

	Matrix(const Matrix &other)
	{
		ASSERT(other.n < 256);
		n = other.n;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = other.a[i][j];
			}
		}
	}

	void unit()
	{

		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	/*
	Matrix operator*(const Matrix &other) const
	{
		ASSERT(n < 256 && other.n < 256);
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}*/

	Matrix operator*(const Matrix &other) const
	{
		Matrix res(n);
		Strassen_class<double> stra;
		stra.Strassen(n, a, other.a, res.a);

		return res;
	}

	Matrix calPow(int k) const
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	double* operator[](int i)
	{
		ASSERT(i < 256);
		return a[i];
	}

	void print() const
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}

	int n;
private:
	//vector<vector<double> > a;
	double **a;
};

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	Matrix mat(stateNum);
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	//mat.print();
	Matrix tranMat = mat.calPow(10000000);
	//Matrix tranMat(mat.power((int)1e6));
	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

template <class T>
struct Matrix
{
	Matrix(int nn) : n(nn), a(nn, vector<T>(nn, 0))
	{

	}
	Matrix(const Matrix<T> &other)
	{
		n = other.n;
		a = other.a;
	}

	void unit()
	{
		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	vector<T>& operator[](int i)
	{
		return a[i];
	}

	Matrix<T> operator*(const Matrix<T> &other) const
	{
		int i, j, k;
		Matrix<T> res(n);
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				T tmp = 0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}
		return res;
	}

	Matrix<T> calPow(ll k)
	{
		Matrix<T> res(n);
		res.unit();

		Matrix<T> b(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * b;
			}

			b = b * b;
			k >>= 1;
		}

		return res;
	}

private:
	vector<vector<T> > a;
	int n;
};

int n, stateNum;
double stay[30];
vector<int> graph[30];
double ans[30];

/*
int getState(int u, int v)
{
	return u * n + v;
}

void getUV(int state, int &u, int &v)
{
	u = state / n;
	v = state % n;
}*/

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}
	u++;
	v++;
	int res = (u - 1) * u / 2 + v - 1;
	return res;
}

void getUV(int state, int &u, int &v)
{
	int i, j;
	state++;
	for (i = 1; i <= n; i++)
	{
		if (state <= i)
		{
			j = state;
			break;
		}
		else
		{
			state -= i;
		}
	}

	u = i - 1;
	v = j - 1;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int m, u, v, i, j, k, a, b, nextState;
	cin >> n >> m >> a >> b;
	a--;
	b--;

	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}

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

	//stateNum = n * n;
	stateNum = n * (n - 1) / 2 + n;

	Matrix<double> mat(stateNum);
	double stayU, stayV, moveU, moveV;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			continue;
		}

		stayU = stay[u];
		stayV = stay[v];
		moveU = (1 - stay[u]) / graph[u].size();
		moveV = (1 - stay[v]) / graph[v].size();
		// both stay
		mat[i][i] += stayU * stayV;

		// u stay v move
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += stayU * moveV;
		}

		// u move v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += moveU * stayV;
		}

		// both move
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += moveU * moveV;
			}
		}
	}

	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u != v)
		{
			mat[i][i] -= 1;
		}
		else
		{
			mat[i][i] = 1;
		}
	}

	Matrix<double> matB(stateNum);
	for (i = 0; i < stateNum; i++)
	{
		matB[i][i] = 1;
	}

	// use gause elimination to solve Ax = b
	for (i = 0; i < stateNum; i++)
	{
		int mxIdx = i;
		for (j = i + 1; j < stateNum; j++)
		{
			if (fabs(mat[j][i])  > fabs(mat[mxIdx][i]))
			{
				mxIdx = j;
			}
		}

		for (j = 0; j < stateNum; j++)
		{
			swap(mat[i][j], mat[mxIdx][j]);
			swap(matB[i][j], matB[mxIdx][j]);
		}

		double div = mat[i][i];
		for (k = i + 1; k < stateNum; k++)
		{
			double mul = -mat[k][i];
			for (j = 0; j < stateNum; j++)
			{
				if (j > i)
				{
					mat[k][j] += mat[i][j] / div * mul;
				}
				else // can be omit
				{
					mat[k][j] = 0;
				}

				matB[k][j] += matB[i][j] / div * mul;
			}
		}
	}

	// backward substitution
	Matrix<double> matX(stateNum);

	// solve k  Ax = b
	for (k = 0; k < stateNum; k++)
	{
		for (i = stateNum - 1; i >= 0; i--)
		{
			double tmp = matB[i][k];
			for (j = i + 1; j < stateNum; j++)
			{
				tmp -= mat[i][j] * matX[j][k];
			}
			matX[i][k] = tmp / mat[i][i];
		}
	}

	int initState = getState(a, b);
	for (u = 0; u < n; u++)
	{
		int finalState = getState(u, u);
		ans[u] = matX[initState][finalState];
	}

	for (i = 0; i < n; i++)
	{
		printf("%.9lf ", ans[i]);
	}
	printf("\n");
	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

template <class T>
struct Matrix
{
	Matrix(int nn) : n(nn), a(nn, vector<T>(nn, 0))
	{

	}
	Matrix(const Matrix<T> &other)
	{
		n = other.n;
		a = other.a;
	}

	void unit()
	{
		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	vector<T>& operator[](int i)
	{
		return a[i];
	}

	Matrix<T> operator*(const Matrix<T> &other) const
	{
		int i, j, k;
		Matrix<T> res(n);
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				T tmp = 0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}
		return res;
	}

	Matrix<T> calPow(ll k)
	{
		Matrix<T> res(n);
		res.unit();

		Matrix<T> b(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * b;
			}

			b = b * b;
			k >>= 1;
		}

		return res;
	}

private:
	vector<vector<T> > a;
	int n;
};

int n, stateNum;
double stay[30];
vector<int> graph[30];
double ans[30];

int getState(int u, int v)
{
	return u * n + v;
}

void getUV(int state, int &u, int &v)
{
	u = state / n;
	v = state % n;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int m, u, v, i, j, k, a, b, nextState;
	cin >> n >> m >> a >> b;
	a--;
	b--;

	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}

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

	stateNum = n * n;

	Matrix<double> mat(stateNum);
	double stayU, stayV, moveU, moveV;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			continue;
		}

		stayU = stay[u];
		stayV = stay[v];
		moveU = (1 - stay[u]) / graph[u].size();
		moveV = (1 - stay[v]) / graph[v].size();
		// both stay
		mat[i][i] += stayU * stayV;

		// u stay v move
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += stayU * moveV;
		}

		// u move v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += moveU * stayV;
		}

		// both move
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += moveU * moveV;
			}
		}
	}

	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u != v)
		{
			mat[i][i] -= 1;
		}
		else
		{
			mat[i][i] = 1;
		}
	}

	Matrix<double> matB(stateNum);
	for (i = 0; i < stateNum; i++)
	{
		matB[i][i] = 1;
	}

	// use gause elimination to solve Ax = b
	for (i = 0; i < stateNum; i++)
	{
		int mxIdx = i;
		for (j = i + 1; j < stateNum; j++)
		{
			if (fabs(mat[j][i])  > fabs(mat[mxIdx][i]))
			{
				mxIdx = j;
			}
		}

		for (j = 0; j < stateNum; j++)
		{
			swap(mat[i][j], mat[mxIdx][j]);
			swap(matB[i][j], matB[mxIdx][j]);
		}

		double div = mat[i][i];
		for (k = i + 1; k < stateNum; k++)
		{
			double mul = -mat[k][i];
			for (j = 0; j < stateNum; j++)
			{
				if (j > i)
				{
					mat[k][j] += mat[i][j] / div * mul;
				}
				else // can be omit
				{
					mat[k][j] = 0;
				}

				matB[k][j] += matB[i][j] / div * mul;
			}
		}
	}

	// backward substitution
	Matrix<double> matX(stateNum);

	// solve k  Ax = b
	for (k = 0; k < stateNum; k++)
	{
		for (i = stateNum - 1; i >= 0; i--)
		{
			double tmp = matB[i][k];
			for (j = i + 1; j < stateNum; j++)
			{
				tmp -= mat[i][j] * matX[j][k];
			}
			matX[i][k] = tmp / mat[i][i];
		}
	}

	int initState = getState(a, b);
	for (u = 0; u < n; u++)
	{
		int finalState = getState(u, u);
		ans[u] = matX[initState][finalState];
	}

	for (i = 0; i < n; i++)
	{
		printf("%.9lf ", ans[i]);
	}
	printf("\n");
	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <assert.h>

#ifndef ONLINE_JUDGE
	#define ASSERT assert
#else
	#define ASSERT(p)
#endif

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

template<typename T>
class Strassen_class{
public:
      void ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );//朴素算法实现
      void FillMatrix( T** MatrixA, T** MatrixB, int length);//A,B矩阵赋值
      void PrintMatrix(T **MatrixA,int MatrixSize);//打印矩阵
      void Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC);//Strassen算法实现
};
template<typename T>
void Strassen_class<T>::ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
        for (int j=0;j<MatrixSize ;j++)
        {
            MatrixResult[i][j]=0;
            for (int k=0;k<MatrixSize ;k++)
            {
                MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
            }
        }
    }
}

/*
c++使用二维数组，申请动态内存方法
申请
int **A;
A = new int *[desired_array_row];
for ( int i = 0; i < desired_array_row; i++)
     A[i] = new int [desired_column_size];

释放
for ( int i = 0; i < your_array_row; i++)
    delete [] A[i];
delete[] A;

*/
template<typename T>
void Strassen_class<T>::Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC)
{

    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 64 )    //分治门槛，小于这个值时不再进行递归计算，而是采用常规矩阵计算方法
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
        T** A11;
        T** A12;
        T** A21;
        T** A22;

        T** B11;
        T** B12;
        T** B21;
        T** B22;

        T** C11;
        T** C12;
        T** C21;
        T** C22;

        T** M1;
        T** M2;
        T** M3;
        T** M4;
        T** M5;
        T** M6;
        T** M7;
        T** AResult;
        T** BResult;

        //making a 1 diminsional pointer based array.
        A11 = new T *[newSize];
        A12 = new T *[newSize];
        A21 = new T *[newSize];
        A22 = new T *[newSize];

        B11 = new T *[newSize];
        B12 = new T *[newSize];
        B21 = new T *[newSize];
        B22 = new T *[newSize];

        C11 = new T *[newSize];
        C12 = new T *[newSize];
        C21 = new T *[newSize];
        C22 = new T *[newSize];

        M1 = new T *[newSize];
        M2 = new T *[newSize];
        M3 = new T *[newSize];
        M4 = new T *[newSize];
        M5 = new T *[newSize];
        M6 = new T *[newSize];
        M7 = new T *[newSize];

        AResult = new T *[newSize];
        BResult = new T *[newSize];

        int newLength = newSize;

        //making that 1 diminsional pointer based array , a 2D pointer based array
        for ( int i = 0; i < newSize; i++)
        {
            A11[i] = new T[newLength];
            A12[i] = new T[newLength];
            A21[i] = new T[newLength];
            A22[i] = new T[newLength];

            B11[i] = new T[newLength];
            B12[i] = new T[newLength];
            B21[i] = new T[newLength];
            B22[i] = new T[newLength];

            C11[i] = new T[newLength];
            C12[i] = new T[newLength];
            C21[i] = new T[newLength];
            C22[i] = new T[newLength];

            M1[i] = new T[newLength];
            M2[i] = new T[newLength];
            M3[i] = new T[newLength];
            M4[i] = new T[newLength];
            M5[i] = new T[newLength];
            M6[i] = new T[newLength];
            M7[i] = new T[newLength];

            AResult[i] = new T[newLength];
            BResult[i] = new T[newLength];

        }
        //splitting input Matrixes, into 4 submatrices each.
        for (int i = 0; i < N / 2; i++)
        {
            for (int j = 0; j < N / 2; j++)
            {
                A11[i][j] = MatrixA[i][j];
                A12[i][j] = MatrixA[i][j + N / 2];
                A21[i][j] = MatrixA[i + N / 2][j];
                A22[i][j] = MatrixA[i + N / 2][j + N / 2];

                B11[i][j] = MatrixB[i][j];
                B12[i][j] = MatrixB[i][j + N / 2];
                B21[i][j] = MatrixB[i + N / 2][j];
                B22[i][j] = MatrixB[i + N / 2][j + N / 2];

            }
        }

        //here we calculate M1..M7 matrices .
        //M1[][]
        ADD( A11,A22,AResult, HalfSize);
        ADD( B11,B22,BResult, HalfSize);                //p5=(a+d)*(e+h)
        Strassen( HalfSize, AResult, BResult, M1 ); //now that we need to multiply this , we use the strassen itself .

        //M2[][]
        ADD( A21,A22,AResult, HalfSize);              //M2=(A21+A22)B11   p3=(c+d)*e
        Strassen(HalfSize, AResult, B11, M2);       //Mul(AResult,B11,M2);

        //M3[][]
        SUB( B12,B22,BResult, HalfSize);              //M3=A11(B12-B22)   p1=a*(f-h)
        Strassen(HalfSize, A11, BResult, M3);       //Mul(A11,BResult,M3);

        //M4[][]
        SUB( B21, B11, BResult, HalfSize);           //M4=A22(B21-B11)    p4=d*(g-e)
        Strassen(HalfSize, A22, BResult, M4);       //Mul(A22,BResult,M4);

        //M5[][]
        ADD( A11, A12, AResult, HalfSize);           //M5=(A11+A12)B22   p2=(a+b)*h
        Strassen(HalfSize, AResult, B22, M5);       //Mul(AResult,B22,M5);

        //M6[][]
        SUB( A21, A11, AResult, HalfSize);
        ADD( B11, B12, BResult, HalfSize);             //M6=(A21-A11)(B11+B12)   p7=(c-a)(e+f)
        Strassen( HalfSize, AResult, BResult, M6);    //Mul(AResult,BResult,M6);

        //M7[][]
        SUB(A12, A22, AResult, HalfSize);
        ADD(B21, B22, BResult, HalfSize);             //M7=(A12-A22)(B21+B22)    p6=(b-d)*(g+h)
        Strassen(HalfSize, AResult, BResult, M7);     //Mul(AResult,BResult,M7);

        //C11 = M1 + M4 - M5 + M7;
        ADD( M1, M4, AResult, HalfSize);
        SUB( M7, M5, BResult, HalfSize);
        ADD( AResult, BResult, C11, HalfSize);

        //C12 = M3 + M5;
        ADD( M3, M5, C12, HalfSize);

        //C21 = M2 + M4;
        ADD( M2, M4, C21, HalfSize);

        //C22 = M1 + M3 - M2 + M6;
        ADD( M1, M3, AResult, HalfSize);
        SUB( M6, M2, BResult, HalfSize);
        ADD( AResult, BResult, C22, HalfSize);

        //at this point , we have calculated the c11..c22 matrices, and now we are going to
        //put them together and make a unit matrix which would describe our resulting Matrix.
        //组合小矩阵到一个大矩阵
        for (int i = 0; i < N/2 ; i++)
        {
            for (int j = 0 ; j < N/2 ; j++)
            {
                MatrixC[i][j] = C11[i][j];
                MatrixC[i][j + N / 2] = C12[i][j];
                MatrixC[i + N / 2][j] = C21[i][j];
                MatrixC[i + N / 2][j + N / 2] = C22[i][j];
            }
        }

        // 释放矩阵内存空间
        for (int i = 0; i < newLength; i++)
        {
            delete[] A11[i];delete[] A12[i];delete[] A21[i];
            delete[] A22[i];

            delete[] B11[i];delete[] B12[i];delete[] B21[i];
            delete[] B22[i];
            delete[] C11[i];delete[] C12[i];delete[] C21[i];
            delete[] C22[i];
            delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
            delete[] M5[i];delete[] M6[i];delete[] M7[i];
            delete[] AResult[i];delete[] BResult[i] ;
        }
        delete[] A11;delete[] A12;delete[] A21;delete[] A22;
        delete[] B11;delete[] B12;delete[] B21;delete[] B22;
        delete[] C11;delete[] C12;delete[] C21;delete[] C22;
        delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
        delete[] M6;delete[] M7;
        delete[] AResult;
        delete[] BResult ;

    }//end of else

}

template<typename T>
void Strassen_class<T>::FillMatrix( T** MatrixA, T** MatrixB, int length)
{
    for(int row = 0; row<length; row++)
    {
        for(int column = 0; column<length; column++)
        {

            MatrixB[row][column] = (MatrixA[row][column] = rand() %5);
            //matrix2[row][column] = rand() % 2;//ba hazfe in khat 50% afzayeshe soorat khahim dasht
        }

    }
}
template<typename T>
void Strassen_class<T>::PrintMatrix(T **MatrixA,int MatrixSize)
{
    cout<<endl;
    for(int row = 0; row<MatrixSize; row++)
    {
        for(int column = 0; column<MatrixSize; column++)
        {

            cout<<MatrixA[row][column]<<"\t";
            if ((column+1)%((MatrixSize)) == 0)
                cout<<endl;
        }

    }
    cout<<endl;
}

struct Matrix
{
	Matrix(int nn)
	{
		ASSERT(nn < 256);
		n = nn;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = 0;
			}
		}
	}

	Matrix(const Matrix &other)
	{
		ASSERT(other.n < 256);
		n = other.n;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = other.a[i][j];
			}
		}
	}

	void unit()
	{

		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	Matrix operator*(const Matrix &other) const
	{
		ASSERT(n < 256 && other.n < 256);
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}
	/*
	Matrix operator*(const Matrix &other) const
	{
		Matrix res(n);
		Strassen_class<double> stra;
		stra.Strassen(n, a, other.a, res.a);

		return res;
	}*/

	Matrix calPow(int k) const
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	double* operator[](int i)
	{
		ASSERT(i < 256);
		return a[i];
	}

	void print() const
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}

	int n;
private:
	//vector<vector<double> > a;
	double **a;
};

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	Matrix mat(stateNum);
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	//mat.print();
	Matrix tranMat = mat.calPow(10000000);
	//Matrix tranMat(mat.power((int)1e6));
	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

const int N = 500;

struct Matrix
{
	Matrix(int nn)
	{
		n = nn;
		a.insert(a.end(), n, vector<double>(n, 0));
	}

	Matrix(const Matrix &other)
	{
		n = other.n;
		a = other.a;
	}

	void unit()
	{
		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	Matrix operator*(const Matrix &other) const
	{
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}

	Matrix power(int k)
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	vector<double>& operator[](int i)
	{
		return a[i];
	}

private:
	vector<vector<double> > a;
	int n;
};

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	// USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	Matrix mat(stateNum);
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	Matrix tranMat = mat.power((int)1e6);

	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <assert.h>

#ifndef ONLINE_JUDGE
	#define ASSERT assert
#else
	#define ASSERT(p)
#endif

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

template<typename T>
class Strassen_class{
public:
      void ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );
      void MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize );//朴素算法实现
      void FillMatrix( T** MatrixA, T** MatrixB, int length);//A,B矩阵赋值
      void PrintMatrix(T **MatrixA,int MatrixSize);//打印矩阵
      void Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC);//Strassen算法实现
};
template<typename T>
void Strassen_class<T>::ADD(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::SUB(T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
}
template<typename T>
void Strassen_class<T>::MUL( T** MatrixA, T** MatrixB, T** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
        for (int j=0;j<MatrixSize ;j++)
        {
            MatrixResult[i][j]=0;
            for (int k=0;k<MatrixSize ;k++)
            {
                MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
            }
        }
    }
}

/*
c++使用二维数组，申请动态内存方法
申请
int **A;
A = new int *[desired_array_row];
for ( int i = 0; i < desired_array_row; i++)
     A[i] = new int [desired_column_size];

释放
for ( int i = 0; i < your_array_row; i++)
    delete [] A[i];
delete[] A;

*/
template<typename T>
void Strassen_class<T>::Strassen(int N, T **MatrixA, T **MatrixB, T **MatrixC)
{

    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 64 )    //分治门槛，小于这个值时不再进行递归计算，而是采用常规矩阵计算方法
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
        T** A11;
        T** A12;
        T** A21;
        T** A22;

        T** B11;
        T** B12;
        T** B21;
        T** B22;

        T** C11;
        T** C12;
        T** C21;
        T** C22;

        T** M1;
        T** M2;
        T** M3;
        T** M4;
        T** M5;
        T** M6;
        T** M7;
        T** AResult;
        T** BResult;

        //making a 1 diminsional pointer based array.
        A11 = new T *[newSize];
        A12 = new T *[newSize];
        A21 = new T *[newSize];
        A22 = new T *[newSize];

        B11 = new T *[newSize];
        B12 = new T *[newSize];
        B21 = new T *[newSize];
        B22 = new T *[newSize];

        C11 = new T *[newSize];
        C12 = new T *[newSize];
        C21 = new T *[newSize];
        C22 = new T *[newSize];

        M1 = new T *[newSize];
        M2 = new T *[newSize];
        M3 = new T *[newSize];
        M4 = new T *[newSize];
        M5 = new T *[newSize];
        M6 = new T *[newSize];
        M7 = new T *[newSize];

        AResult = new T *[newSize];
        BResult = new T *[newSize];

        int newLength = newSize;

        //making that 1 diminsional pointer based array , a 2D pointer based array
        for ( int i = 0; i < newSize; i++)
        {
            A11[i] = new T[newLength];
            A12[i] = new T[newLength];
            A21[i] = new T[newLength];
            A22[i] = new T[newLength];

            B11[i] = new T[newLength];
            B12[i] = new T[newLength];
            B21[i] = new T[newLength];
            B22[i] = new T[newLength];

            C11[i] = new T[newLength];
            C12[i] = new T[newLength];
            C21[i] = new T[newLength];
            C22[i] = new T[newLength];

            M1[i] = new T[newLength];
            M2[i] = new T[newLength];
            M3[i] = new T[newLength];
            M4[i] = new T[newLength];
            M5[i] = new T[newLength];
            M6[i] = new T[newLength];
            M7[i] = new T[newLength];

            AResult[i] = new T[newLength];
            BResult[i] = new T[newLength];

        }
        //splitting input Matrixes, into 4 submatrices each.
        for (int i = 0; i < N / 2; i++)
        {
            for (int j = 0; j < N / 2; j++)
            {
                A11[i][j] = MatrixA[i][j];
                A12[i][j] = MatrixA[i][j + N / 2];
                A21[i][j] = MatrixA[i + N / 2][j];
                A22[i][j] = MatrixA[i + N / 2][j + N / 2];

                B11[i][j] = MatrixB[i][j];
                B12[i][j] = MatrixB[i][j + N / 2];
                B21[i][j] = MatrixB[i + N / 2][j];
                B22[i][j] = MatrixB[i + N / 2][j + N / 2];

            }
        }

        //here we calculate M1..M7 matrices .
        //M1[][]
        ADD( A11,A22,AResult, HalfSize);
        ADD( B11,B22,BResult, HalfSize);                //p5=(a+d)*(e+h)
        Strassen( HalfSize, AResult, BResult, M1 ); //now that we need to multiply this , we use the strassen itself .

        //M2[][]
        ADD( A21,A22,AResult, HalfSize);              //M2=(A21+A22)B11   p3=(c+d)*e
        Strassen(HalfSize, AResult, B11, M2);       //Mul(AResult,B11,M2);

        //M3[][]
        SUB( B12,B22,BResult, HalfSize);              //M3=A11(B12-B22)   p1=a*(f-h)
        Strassen(HalfSize, A11, BResult, M3);       //Mul(A11,BResult,M3);

        //M4[][]
        SUB( B21, B11, BResult, HalfSize);           //M4=A22(B21-B11)    p4=d*(g-e)
        Strassen(HalfSize, A22, BResult, M4);       //Mul(A22,BResult,M4);

        //M5[][]
        ADD( A11, A12, AResult, HalfSize);           //M5=(A11+A12)B22   p2=(a+b)*h
        Strassen(HalfSize, AResult, B22, M5);       //Mul(AResult,B22,M5);

        //M6[][]
        SUB( A21, A11, AResult, HalfSize);
        ADD( B11, B12, BResult, HalfSize);             //M6=(A21-A11)(B11+B12)   p7=(c-a)(e+f)
        Strassen( HalfSize, AResult, BResult, M6);    //Mul(AResult,BResult,M6);

        //M7[][]
        SUB(A12, A22, AResult, HalfSize);
        ADD(B21, B22, BResult, HalfSize);             //M7=(A12-A22)(B21+B22)    p6=(b-d)*(g+h)
        Strassen(HalfSize, AResult, BResult, M7);     //Mul(AResult,BResult,M7);

        //C11 = M1 + M4 - M5 + M7;
        ADD( M1, M4, AResult, HalfSize);
        SUB( M7, M5, BResult, HalfSize);
        ADD( AResult, BResult, C11, HalfSize);

        //C12 = M3 + M5;
        ADD( M3, M5, C12, HalfSize);

        //C21 = M2 + M4;
        ADD( M2, M4, C21, HalfSize);

        //C22 = M1 + M3 - M2 + M6;
        ADD( M1, M3, AResult, HalfSize);
        SUB( M6, M2, BResult, HalfSize);
        ADD( AResult, BResult, C22, HalfSize);

        //at this point , we have calculated the c11..c22 matrices, and now we are going to
        //put them together and make a unit matrix which would describe our resulting Matrix.
        //组合小矩阵到一个大矩阵
        for (int i = 0; i < N/2 ; i++)
        {
            for (int j = 0 ; j < N/2 ; j++)
            {
                MatrixC[i][j] = C11[i][j];
                MatrixC[i][j + N / 2] = C12[i][j];
                MatrixC[i + N / 2][j] = C21[i][j];
                MatrixC[i + N / 2][j + N / 2] = C22[i][j];
            }
        }

        // 释放矩阵内存空间
        for (int i = 0; i < newLength; i++)
        {
            delete[] A11[i];delete[] A12[i];delete[] A21[i];
            delete[] A22[i];

            delete[] B11[i];delete[] B12[i];delete[] B21[i];
            delete[] B22[i];
            delete[] C11[i];delete[] C12[i];delete[] C21[i];
            delete[] C22[i];
            delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
            delete[] M5[i];delete[] M6[i];delete[] M7[i];
            delete[] AResult[i];delete[] BResult[i] ;
        }
        delete[] A11;delete[] A12;delete[] A21;delete[] A22;
        delete[] B11;delete[] B12;delete[] B21;delete[] B22;
        delete[] C11;delete[] C12;delete[] C21;delete[] C22;
        delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
        delete[] M6;delete[] M7;
        delete[] AResult;
        delete[] BResult ;

    }//end of else

}

template<typename T>
void Strassen_class<T>::FillMatrix( T** MatrixA, T** MatrixB, int length)
{
    for(int row = 0; row<length; row++)
    {
        for(int column = 0; column<length; column++)
        {

            MatrixB[row][column] = (MatrixA[row][column] = rand() %5);
            //matrix2[row][column] = rand() % 2;//ba hazfe in khat 50% afzayeshe soorat khahim dasht
        }

    }
}
template<typename T>
void Strassen_class<T>::PrintMatrix(T **MatrixA,int MatrixSize)
{
    cout<<endl;
    for(int row = 0; row<MatrixSize; row++)
    {
        for(int column = 0; column<MatrixSize; column++)
        {

            cout<<MatrixA[row][column]<<"\t";
            if ((column+1)%((MatrixSize)) == 0)
                cout<<endl;
        }

    }
    cout<<endl;
}

struct Matrix
{
	Matrix(int nn)
	{
		ASSERT(nn < 256);
		n = nn;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = 0;
			}
		}
	}

	Matrix(const Matrix &other)
	{
		ASSERT(other.n < 256);
		n = other.n;
		a = new double*[n];
		for (int i = 0; i < n; i++)
		{
			a[i] = new double[n];
			for (int j = 0; j < n; j++)
			{
				a[i][j] = other.a[i][j];
			}
		}
	}

	void unit()
	{

		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	Matrix operator*(const Matrix &other) const
	{
		ASSERT(n < 256 && other.n < 256);
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}
	/*
	Matrix operator*(const Matrix &other) const
	{
		Matrix res(n);
		Strassen_class<double> stra;
		stra.Strassen(n, a, other.a, res.a);

		return res;
	}*/

	Matrix calPow(int k) const
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	double* operator[](int i)
	{
		ASSERT(i < 256);
		return a[i];
	}

	void print() const
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}

	int n;
private:
	//vector<vector<double> > a;
	double **a;
};

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	Matrix mat(stateNum);
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	//mat.print();
	Matrix tranMat = mat.calPow(100000);
	//Matrix tranMat(mat.power((int)1e6));
	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <assert.h>

#ifndef ONLINE_JUDGE
	#define ASSERT assert
#else
	#define ASSERT(p)
#endif

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

const int N = 500;

struct Matrix
{
	Matrix(int nn = 10)
	{
		ASSERT(nn < 256);
		n = nn;
		memset(a, 0, sizeof(a));
	}

	Matrix(const Matrix &other)
	{
		ASSERT(other.n < 256);
		n = other.n;
		memcpy(a, other.a, sizeof(a));
	}

	void unit()
	{

		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	Matrix operator*(const Matrix &other) const
	{
		ASSERT(n < 256 && other.n < 256);
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}

	Matrix calPow(int k) const
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	double* operator[](int i)
	{
		ASSERT(i < 256);
		return &a[i][0];
	}

	void print() const
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}

	int n;
private:
	//vector<vector<double> > a;
	double a[254][254];
} mat, tranMat;

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	mat.n = tranMat.n = stateNum;
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	mat.print();
	tranMat = mat.calPow(100000);
	//Matrix tranMat(mat.power((int)1e6));
	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


// include stdc++.h slows down compilation much.
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <assert.h>

#ifndef ONLINE_JUDGE
	#define ASSERT assert
#else
	#define ASSERT(p)
#endif

using namespace std;

#define USE_IOSTREAM \
{\
	ios::sync_with_stdio(false);\
	cin.tie(0);\
	cout.tie(0);\
}

#define pii pair<int, int>
#define mp make_pair

typedef long long ll;

const int N = 500;

struct Matrix
{
	Matrix(int nn = 10)
	{
		ASSERT(nn < 256);
		n = nn;
		memset(a, 0, sizeof(a));
	}

	Matrix(const Matrix &other)
	{
		ASSERT(other.n < 256);
		n = other.n;
		memcpy(a, other.a, sizeof(a));
	}

	void unit()
	{

		for (int i = 0; i < n; i++)
		{
			a[i][i] = 1;
		}
	}

	Matrix operator*(const Matrix &other) const
	{
		ASSERT(n < 256 && other.n < 256);
		Matrix res(n);
		int i, j, k;
		for (i = 0; i < n; i++)
		{
			for (j = 0; j < n; j++)
			{
				double tmp = 0.0;
				for (k = 0; k < n; k++)
				{
					tmp += a[i][k] * other.a[k][j];
				}
				res.a[i][j] = tmp;
			}
		}

		return res;
	}

	Matrix calPow(int k) const
	{
		Matrix res(n);
		res.unit();
		Matrix cur(*this);
		while (k)
		{
			if (k & 1)
			{
				res = res * cur;
			}

			cur = cur * cur;
			k >>= 1;
		}

		return res;
	}

	double* operator[](int i)
	{
		ASSERT(i < 256);
		return &a[i][0];
	}

	void print() const
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				cout << a[i][j] << " ";
			}
		}
		cout << endl;
	}

	int n;
private:
	//vector<vector<double> > a;
	double a[254][254];
} mat, tranMat;

double p[30];
vector<int> graph[30];
double ans[30];

void getUV(int state, int &u, int &v)
{
	int i, j;
	j = state + 1;
	for (i = 1; true; i++)
	{
		if (j > i)
		{
			j -= i;
		}
		else
		{
			break;
		}
	}

	u = i - 1;
	v = j - 1;
}

int getState(int u, int v)
{
	if (u < v)
	{
		swap(u, v);
	}

	u++;
	v++;
	int res = u * (u - 1) / 2 + v - 1;

	return res;
}

int main()
{
	USE_IOSTREAM;
	#ifndef ONLINE_JUDGE
	freopen("1.txt", "r", stdin);
	#endif

	int n, m, i, u, v, a, b, nextState, initState;
	cin >> n >> m >> a >> b;
	a--;
	b--;
	for (i = 0; i < m; i++)
	{
		cin >> u >> v;
		u--;
		v--;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}
	for (i = 0; i < n; i++)
	{
		cin >> p[i];
	}

	if (a < b)
	{
		swap(a, b);
	}
	// to reduce stateNum, let u >= v

	int stateNum = n * (n - 1) / 2 + n;
	mat.n = tranMat.n = stateNum;
	double tmp, pu, pv;
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);

		// both stay
		mat[i][i] += p[u] * p[v];

		pu = (1.0 - p[u]) / graph[u].size();
		pv = (1.0 - p[v]) / graph[v].size();

		// u leave, v stay
		for (auto nextU : graph[u])
		{
			nextState = getState(nextU, v);
			mat[i][nextState] += pu * p[v];
		}

		// u stay, v leave
		for (auto nextV : graph[v])
		{
			nextState = getState(u, nextV);
			mat[i][nextState] += p[u] * pv;
		}

		// both leave
		tmp = pu * pv;
		for (auto nextU : graph[u])
		{
			for (auto nextV : graph[v])
			{
				nextState = getState(nextU, nextV);
				mat[i][nextState] += tmp;
			}
		}
	}

	for (u = 0; u < n; u++)
	{
		int curState = getState(u, u);
		for (i = 0; i < stateNum; i++)
		{
			mat[curState][i] = 0;
		}
		mat[curState][curState] = 1;
	}

	//mat.print();
	tranMat = mat.calPow(100000);
	//Matrix tranMat(mat.power((int)1e6));
	initState = getState(a, b);
	for (i = 0; i < stateNum; i++)
	{
		getUV(i, u, v);
		if (u == v)
		{
			ans[u] = tranMat[initState][i];
		}
	}

	for (i = 0; i < n; i++)
	{
		printf("%.8lf ", ans[i]);
	}
	printf("\n");

	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<map>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<iostream>
#include<queue>
#include<stack>
#include<cassert>
#include<set>
#include<map>
#define y1 dnjsfndkls
#define pb push_back
#define fir first
#define sec second
#define tm suifhsduifhais
#define all(a) a.begin(),a.end()
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
const double PI=acos(-1.0);
template<class T>
void Read(T &x){
    char c;
    bool f=0;
    while(c=getchar(),c!=EOF)
        if(c=='-') f=1;
        else if(c>='0'&&c<='9'){
            x=c-'0';
            while(c=getchar(),c>='0'&&c<='9')
                x=x*10+c-'0';
            ungetc(c,stdin);
            if(f) x=-x;
            return ;
        }
}
namespace arr{
inline int lowbit(int x){
	return x&(-x);
}
template<class T>
inline void arrUpdate(T *c,int x,T d,int N){
	while(x<=N){
		c[x]+=d;
		x+=lowbit(x);
	}
}
template<class T>
inline T arrGetsum(T *c,int x){
	T ret=0;
	while(x){
		ret+=c[x];
		x-=lowbit(x);
	}
	return ret;
}
}
//****************************************

#define MAXN 22
const double eps=1e-10;

int n,m,A,B,equ,var,deg[MAXN+10],mat[MAXN+10][MAXN+10];
double a[MAXN*MAXN+10][MAXN*MAXN+10],p[MAXN+10],x[MAXN*MAXN+10];

inline int Getid(int i,int j){
	return (i-1)*n+j;
}
void read(){
	int x,y;
	Read(n),Read(m),Read(A),Read(B);
	for(int i=1;i<=m;i++){
		Read(x),Read(y);
		++deg[x],++deg[y];
		mat[x][y]=mat[y][x]=1;
	}
	for(int i=1;i<=n;i++)
		scanf("%lf",&p[i]);
	equ=var=n*n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			for(int k=1;k<=n;k++)
				for(int l=1;l<=n;l++){
					if(k==l) continue;
					int st=Getid(i,j),ed=Getid(k,l);
					if(i==k&&j==l)
						a[st][ed]=p[k]*p[l];
					if(mat[i][k]&&mat[j][l])
						a[st][ed]=(1.0-p[k])/deg[k]*(1.0-p[l])/deg[l];
					if(mat[i][k]&&j==l)
						a[st][ed]=(1.0-p[k])/deg[k]*p[l];
					if(i==k&&mat[j][l])
						a[st][ed]=p[k]*(1.0-p[l])/deg[l];
				}
	for(int i=1;i<=var;i++)
		a[i][i]-=1;
	a[Getid(A,B)][var+1]=-1;
}
void Gauss_Jordan(){
	int row=1,col=1,mx;
	for(;row<=equ&&col<=var;row++,col++){
		mx=row;
		for(int i=row+1;i<=equ;i++)
			if(fabs(a[i][col])>fabs(a[mx][col]))
				mx=i;
		if(mx!=row)
			swap(a[mx],a[row]);
		if(fabs(a[row][col])<eps){
			row--;
			continue;
		}
		for(int i=1;i<=equ;i++){
			if(i==row||fabs(a[i][col])<eps) continue;
			for(int j=var+1;j>=col;j--)
				a[i][j]-=a[row][j]*a[i][col]/a[row][col];
		}
	}
	for(int i=row-1;i>=1;i--)
		x[i]=a[i][var+1]/a[i][i];
	for(int i=1;i<=n;i++)
		printf("%.9f ",x[Getid(i,i)]);
}
int main()
{
	read();
	Gauss_Jordan();
	return 0;
}


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

const int N = 505;
const double eps = 1e-8;
#define rep(i,a,b) for(int i=a;i<b;i++)
double A[N][N];

void Gauss(int n, int m) {
	int i = 0, x = 0;
	for (; i < n && x < m; i++, x++) {
		int r = i;
		rep(j,i+1,n) if (fabs(A[j][x]) > fabs(A[r][x])) {r=j;}
		if (fabs(A[r][x]) < eps) --i;
		else {
			if (r!=i) rep(j,0,m+1) swap(A[r][j],A[i][j]);
			for (int j = m; j >= x; j--) A[i][j] /= A[i][x];
			rep(j,0,n) if (i!=j && A[j][x])
			for (int k = m; k >= x; k--)
				A[j][k] -= A[i][k] * A[j][x];
		}
	}
}

int n, a, b, m;
int g[25][25], d[25];
double p[25][25];

int main() {
	scanf("%d%d%d%d", &n, &m, &a, &b);
	a--; b--;
	int u, v;
	while (m--) {
		scanf("%d%d", &u, &v);
		u--; v--;
		g[u][v] = g[v][u] = 1;
		d[u]++; d[v]++;
	}
	for (int i = 0; i < n; i++) scanf("%lf", &p[i][i]);
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			if (i != j && g[i][j]) p[i][j] = (1 - p[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) continue;
			for (int k = 0; k < n; k++)
				for (int l = 0; l < n; l++)
					A[k * n + l][i * n + j] += p[i][k] * p[j][l];
		}
	}
	//A[a * n + b][n * n] -= 1.0;
/*	for (int i = 0; i < n*n; i++)
	{
		for(int j=v=i;j<n*n;j++)
			if(fabs(A[j][i])>fabs(A[v][i]))
				v=j;
		for (int k =0; k <=n*n; k++)
			swap(A[v][k],A[i][k]);
		double u;
		u=A[i][i];
		for (int k = 0; k <=n * n ;k++)
			A[i][k]/=u;
		for (int j =0; j<n*n;j++)
			if(u=A[j][i],i!=j)
				for (int k = 0; k <=n * n;k++)
					A[j][k]-=u*A[i][k];
	}*/
	Gauss(n * n, n * n);
	for (int i = 0; i < n; i++) printf("%.10f ", A[i * n + i][n * n]); printf("\n");
	return 0;
}
//by joyfun


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF=1e9+7,MAXN=25,MAXM=600;
int head[MAXN],sz,to[MAXM],nxt[MAXM];
inline void add(int x,int y) {
	nxt[++sz]=head[x],head[x]=sz,to[sz]=y;
	nxt[++sz]=head[y],head[y]=sz,to[sz]=x;
}
int N,M,a,b,deg[MAXN];/*input*/
double p[MAXN];
int id[MAXN][MAXN];/*init*/
double mat[MAXM][MAXM],ans[MAXM],f[MAXN][MAXN];
int main() {
	scanf("%d%d%d%d",&N,&M,&a,&b);
	for(int i=1; i<=M; i++) {
		int ii,jj;
		scanf("%d%d",&ii,&jj);
		add(ii,jj);
		deg[ii]++,deg[jj]++;
	}
	for(int i=1; i<=N; i++) {
		scanf("%lf",p+i);
	}
	/*init*/
	M=0;
	for(int i=1; i<=N; i++) {
		for(int j=1; j<=N; j++) {
			id[i][j]=++M;
		}
	}
	/*calculate the cost of each transfer*/
	mat[id[a][b]][M+1]=-1;/*end*/
	for(int i=1; i<=N; i++) {
		for(int j=1; j<=N; j++) {
			int ii=id[i][j];
			mat[ii][ii]-=1;
			if(i!=j)
				mat[ii][ii]+=p[i]*p[j];/*stay*/
			for(int k=head[i]; k; k=nxt[k]) {
				for(int l=head[j]; l; l=nxt[l]) {
					int u=to[k],v=to[l];
					if(u==v)
						continue;
					mat[ii][id[u][v]]=
					  (1-p[u])*(1-p[v])
					  /deg[u]/deg[v];
				}
			}
			for(int k=head[i];k;k=nxt[k]){
				int u=to[k];
				if(u==j)
					continue;
				mat[ii][id[u][j]]=(1-p[u])*p[j]/deg[u];
			}
			for(int k=head[j];k;k=nxt[k]){
				int v=to[k];
				if(i==v)
					continue;
				mat[ii][id[i][v]]=p[i]*(1-p[v])/deg[v];
			}
		}
	}
	/*gauss elimination*/
	for(int i=1;i<=M;i++){
		int r=i;
		for(int j=i;j<=M;j++){
			if(abs(mat[j][i])>abs(mat[r][i]))
				r=j;
		}
		swap(mat[r],mat[i]);
		for(int j=1;j<=M;j++){
			if(i==j)/**/
				continue;
			double t=mat[j][i]/mat[i][i];
			for(int k=i;k<=M+1;k++){
				mat[j][k]-=mat[i][k]*t;
			}
		}
	}
	for(int i=1;i<=N;i++){
		for(int j=1;j<=N;j++){
			f[i][j]=mat[id[i][j]][M+1]/mat[id[i][j]][id[i][j]];
		}
	}

	for(int i=1;i<=N;i++){
		printf("%.7lf ",f[i][i]);
	}
	return 0;
}