Problem: A chip was placed on a field with coordinate system onto point (0, 0).

Every second the chip moves randomly. If the chip is currently at a point (x, y), after a second it moves to the point (x - 1, y) with probability p1, to the point (x, y - 1) with probability p2, to the point (x + 1, y) with probability p3 and to the point (x, y + 1) with probability p4. It's guaranteed that p1 + p2 + p3 + p4 = 1. The moves are independent.

Find out the expected time after which chip will move away from origin at a distance greater than R (i.e. <image> will be satisfied).

Input

First line contains five integers R, a1, a2, a3 and a4 (0 ≤ R ≤ 50, 1 ≤ a1, a2, a3, a4 ≤ 1000).

Probabilities pi can be calculated using formula <image>.

Output

It can be shown that answer for this problem is always a rational number of form <image>, where <image>.

Print P·Q - 1 modulo 109 + 7. 

Examples

Input

0 1 1 1 1


Output

1

Input

1 1 1 1 1


Output

666666674

Input

1 1 2 1 2


Output

538461545

Note

In the first example initially the chip is located at a distance 0 from origin. In one second chip will move to distance 1 is some direction, so distance to origin will become 1.

Answers to the second and the third tests: <image> and <image>.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 105;
int dat[MAXN], a[MAXN][MAXN][MAXN], f[MAXN][MAXN];
inline int read() {
  int x = 0;
  char ch = getchar();
  while (!isdigit(ch)) ch = getchar();
  while (isdigit(ch)) {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x;
}
template <typename T1, typename T2>
inline void Add(T1 &x, T2 y) {
  x += y, x >= MOD && (x -= MOD);
}
inline int qpow(int x, int y = MOD - 2) {
  long long r = 1, k = x;
  while (y) {
    if (y & 1) r *= k, r %= MOD;
    k *= k, k %= MOD, y >>= 1;
  }
  return r;
}
int main() {
  int r = read();
  int p1 = read(), p2 = read();
  int p3 = read(), p4 = read();
  int inv = qpow((1ll * p1 + p2 + p3 + p4) % MOD);
  p1 = 1ll * p1 * inv % MOD, p2 = 1ll * p2 * inv % MOD;
  p3 = 1ll * p3 * inv % MOD, p4 = 1ll * p4 * inv % MOD;
  int inv3 = qpow(p3), *dat = ::dat + 50;
  for (int i = -r; i <= r; i++) {
    dat[i] = -sqrt(r * r - i * i);
    a[dat[i] + r][i + r][i + r] = 1;
  }
  for (int i = -r; i <= r; i++) {
    int s = dat[i], t = -dat[i];
    for (int j = s; j <= t; j++) {
      for (int k = 0; k <= r * 2 + 1; k++) {
        a[i + 1 + r][j + r][k] =
            ((1ll * a[i + r][j + r][k] -
              (i == -r ? 0 : 1ll * p1 * a[i - 1 + r][j + r][k]) -
              (j == -r ? 0 : 1ll * p2 * a[i + r][j - 1 + r][k]) -
              1ll * p4 * a[i + r][j + 1 + r][k]) %
                 MOD +
             MOD) %
            MOD;
        if (k == 2 * r + 1) Add(a[i + 1 + r][j + r][k], MOD - 1);
        a[i + 1 + r][j + r][k] = 1ll * a[i + 1 + r][j + r][k] * inv3 % MOD;
      }
    }
  }
  for (int i = -r; i <= r; i++) {
    int t = -dat[i];
    memcpy(f[i + r], a[t + 1 + r][i + r], sizeof(f[i + r]));
    f[i + r][2 * r + 1] = MOD - a[t + 1 + r][i + r][2 * r + 1];
  }
  for (int i = 0; i <= 2 * r; i++) {
    for (int j = i; j <= 2 * r && !f[i][i]; j++)
      if (f[j][i]) swap(f[i], f[j]);
    int inv = qpow(f[i][i]);
    for (int j = 0; j <= 2 * r; j++) {
      if (j == i) continue;
      int tmp = 1ll * f[j][i] * inv % MOD;
      for (int k = i; k <= 2 * r + 1; k++)
        f[j][k] -= 1ll * tmp * f[i][k] % MOD, f[j][k] += MOD, f[j][k] %= MOD;
    }
  }
  int ans = 0;
  for (int i = 0; i <= 2 * r; i++)
    ans = (ans +
           1ll * a[r][r][i] * f[i][2 * r + 1] % MOD * qpow(f[i][i], MOD - 2)) %
          MOD;
  return Add(ans, a[r][r][r * 2 + 1]), printf("%d\n", ans), 0;
}