```go
package main

import (
	"fmt"
	"io"
)

const MOD = 1000000007

func powMod(a, b int64) int64 {
	res := int64(1)
	a %= MOD
	if a < 0 {
		a += MOD
	}
	for b > 0 {
		if b&1 != 0 {
			res = (res * a) % MOD
		}
		a = (a * a) % MOD
		b >>= 1
	}
	return res
}

func modInverse(n int64) int64 {
	return powMod(n, MOD-2)
}

func main() {
	var R, a1, a2, a3, a4 int64
	if _, err := fmt.Scan(&R, &a1, &a2, &a3, &a4); err != nil && err != io.EOF {
		return
	}

	S := (a1 + a2 + a3 + a4) % MOD
	invS := modInverse(S)

	p1 := (a1 * invS) % MOD
	p2 := (a2 * invS) % MOD
	p3 := (a3 * invS) % MOD
	p4 := (a4 * invS) % MOD

	idx := make(map[[2]int]int)
	points := [][2]int{}
	id := 0
	for y := -int(R); y <= int(R); y++ {
		for x := -int(R); x <= int(R); x++ {
			if x*x+y*y <= int(R)*int(R) {
				idx[[2]int{x, y}] = id
				points = append(points, [2]int{x, y})
				id++
			}
		}
	}
	N := id

	if N == 0 {
		fmt.Println(0)
		return
	}

	W := 105
	rowSize := 3*W + 1
	A := make([][]int64, N)
	for i := 0; i < N; i++ {
		A[i] = make([]int64, rowSize)
	}
	B := make([]int64, N)

	dirs := []struct {
		dx, dy int
		p      int64
	}{
		{-1, 0, p1},
		{0, -1, p2},
		{1, 0, p3},
		{0, 1, p4},
	}

	for i := 0; i < N; i++ {
		pt := points[i]
		x, y := pt[0], pt[1]

		A[i][W] = 1

		for _, d := range dirs {
			nx, ny := x+d.dx, y+d.dy
			if nx*nx+ny*ny <= int(R)*int(R) {
				nc := idx[[2]int{nx, ny}]
				A[i][nc-i+W] = (MOD - d.p) % MOD
			}
		}
		B[i] = 1
	}

	rightMost := make([]int, N)
	for i := 0; i < N; i++ {
		rightMost[i] = i + W
		if rightMost[i] > N {
			rightMost[i] = N
		}
	}

	for i := 0; i < N; i++ {
		pivot := i
		for j := i; j <= i+W && j < N; j++ {
			if A[j][i-j+W] != 0 {
				pivot = j
				break
			}
		}

		if pivot != i {
			maxC := rightMost[pivot]
			if rightMost[i] > maxC {
				maxC = rightMost[i]
			}
			for c := i; c < maxC; c++ {
				A[i][c-i+W], A[pivot][c-pivot+W] = A[pivot][c-pivot+W], A[i][c-i+W]
			}
			B[i], B[pivot] = B[pivot], B[i]
			rightMost[i], rightMost[pivot] = rightMost[pivot], rightMost[i]
		}

		inv := modInverse(A[i][W])
		maxC := rightMost[i]
		for c := i; c < maxC; c++ {
			idxC := c - i + W
			if A[i][idxC] != 0 {
				A[i][idxC] = (A[i][idxC] * inv) % MOD
			}
		}
		B[i] = (B[i] * inv) % MOD

		maxR := i + W + 1
		if maxR > N {
			maxR = N
		}
		for j := i + 1; j < maxR; j++ {
			factor := A[j][i-j+W]
			if factor != 0 {
				for c := i; c < maxC; c++ {
					valI := A[i][c-i+W]
					if valI != 0 {
						idxJ := c - j + W
						val := A[j][idxJ] - factor*valI
						val %= MOD
						if val < 0 {
							val += MOD
						}
						A[j][idxJ] = val
					}
				}
				B[j] = (B[j] - factor*B[i]) % MOD
				if B[j] < 0 {
					B[j] += MOD
				}
				if rightMost[i] > rightMost[j] {
					rightMost[j] = rightMost[i]
				}
			}
		}
	}

	ans := (B[idx[[2]int{0, 0}]] % MOD + MOD) % MOD
	fmt.Println(ans)
}
```