```go
package main

import (
	"fmt"
)

func main() {
	var n, m, a, b int
	if _, err := fmt.Scan(&n, &m, &a, &b); err != nil {
		return
	}
	a--
	b--

	adj := make([][]int, n)
	for i := 0; i < m; i++ {
		var u, v int
		fmt.Scan(&u, &v)
		u--
		v--
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	p := make([]float64, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&p[i])
	}

	if a == b {
		for i := 0; i < n; i++ {
			if i == a {
				fmt.Printf("1.0 ")
			} else {
				fmt.Printf("0.0 ")
			}
		}
		fmt.Println()
		return
	}

	P := make([][]float64, n)
	for i := 0; i < n; i++ {
		P[i] = make([]float64, n)
		P[i][i] = p[i]
		deg := len(adj[i])
		if deg > 0 {
			prob := (1.0 - p[i]) / float64(deg)
			for _, v := range adj[i] {
				P[i][v] = prob
			}
		}
	}

	K := n * (n - 1) / 2
	A := make([][]float64, K)
	for i := range A {
		A[i] = make([]float64, K)
	}
	B := make([]float64, K)

	getIndex := func(u, v int) int {
		if u > v {
			u, v = v, u
		}
		idx := 0
		for i := 0; i < u; i++ {
			idx += n - 1 - i
		}
		idx += v - u - 1
		return idx
	}

	for u := 0; u < n; u++ {
		for v := u + 1; v < n; v++ {
			row := getIndex(u, v)
			if (a == u && b == v) || (a == v && b == u) {
				B[row] = 1.0
			}
			for up := 0; up < n; up++ {
				for vp := up + 1; vp < n; vp++ {
					col := getIndex(up, vp)
					term := P[up][u]*P[vp][v] + P[up][v]*P[vp][u]
					if row == col {
						A[row][col] = 1.0 - term
					} else {
						A[row][col] = -term
					}
				}
			}
		}
	}

	for i := 0; i < K; i++ {
		pivot := i
		for j := i + 1; j < K; j++ {
			if abs(A[j][i]) > abs(A[pivot][i]) {
				pivot = j
			}
		}
		A[i], A[pivot] = A[pivot], A[i]
		B[i], B[pivot] = B[pivot], B[i]

		inv := 1.0 / A[i][i]
		for j := i; j < K; j++ {
			A[i][j] *= inv
		}
		B[i] *= inv

		for j := 0; j < K; j++ {
			if i != j && A[j][i] != 0 {
				factor := A[j][i]
				for k := i; k < K; k++ {
					A[j][k] -= factor * A[i][k]
				}
				B[j] -= factor * B[i]
			}
		}
	}

	ans := make([]float64, n)
	for k := 0; k < n; k++ {
		for up := 0; up < n; up++ {
			for vp := up + 1; vp < n; vp++ {
				col := getIndex(up, vp)
				ans[k] += B[col] * P[up][k] * P[vp][k]
			}
		}
	}

	for i := 0; i < n; i++ {
		fmt.Printf("%.10f ", ans[i])
	}
	fmt.Println()
}

func abs(x float64) float64 {
	if x < 0 {
		return -x
	}
	return x
}
```