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>
#pragma GCC optimize(2)
#pragma GCC target("avx")
using namespace std;
inline int read() {
  char ch = getchar();
  int w = 1, c = 0;
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') w = -1;
  for (; isdigit(ch); ch = getchar()) c = (c << 1) + (c << 3) + (ch ^ 48);
  return w * c;
}
const int mod = 1e9 + 7;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int n, R, tt;
long long a[4];
long long fast(long long x, long long p) {
  long long ret = 1;
  for (; p; p >>= 1, x = x * x % mod)
    if (p & 1) ret = ret * x % mod;
  return ret;
}
const int M = 7850;
int c[M][M];
long long b[M];
int d, vis[M], ps[M], bd[200][200];
void gauss() {
  d = 2 * R;
  for (int i = (1); i <= (tt); ++i) {
    for (int j = i; j <= min(tt, i + d); j++) {
      if (c[j][i]) {
        if (i ^ j) swap(c[j], c[i]);
        break;
      }
    }
    long long iv = mod - fast(c[i][i], mod - 2);
    for (int j = i + 1; j <= min(tt, i + d); j++) {
      long long t = iv * c[j][i] % mod;
      for (int x = (i); x <= (min(i + 2 * d, tt)); ++x)
        c[j][x] = (c[j][x] + (long long)t * c[i][x]) % mod;
      b[j] = (b[j] + b[i] * t) % mod;
    }
  }
  for (int i = (tt); i >= (1); --i) {
    for (int j = (max(1, i - d)); j <= (min(tt, i + d)); ++j) {
      if (j ^ i) b[i] = (b[i] + (long long)(mod - c[i][j]) * b[j]) % mod;
    }
    b[i] = b[i] * fast(c[i][i], mod - 2) % mod;
  }
}
int main() {
  R = read();
  int sm = 0;
  for (int i = (0); i <= (3); ++i) a[i] = read(), sm += a[i];
  sm = fast(sm, mod - 2);
  for (int i = (0); i <= (3); ++i) a[i] = a[i] * sm % mod;
  for (int i = (-R); i <= (R); ++i) {
    for (int j = (-R); j <= (R); ++j) {
      if (i * i + j * j <= R * R) {
        bd[i + R][j + R] = ++tt;
      }
    }
  }
  for (int i = (-R); i <= (R); ++i) {
    for (int j = (-R); j <= (R); ++j) {
      if (i * i + j * j <= R * R) {
        int u = bd[i + R][j + R];
        c[u][u] = 1;
        for (int k = (0); k <= (3); ++k) {
          int nx = i + dx[k], ny = j + dy[k];
          if (nx * nx + ny * ny <= R * R) {
            int v = bd[nx + R][ny + R];
            c[u][v] = mod - a[k];
          }
        }
        b[u] = 1;
      }
    }
  }
  gauss();
  cout << b[bd[0 + R][0 + R]] << "\n";
  return 0;
}