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, N = 8005;
long double sq(int x, int y) { return sqrt(x * x + y * y); }
vector<pair<int, int> > pt;
int id[105][105];
long long r, p1, p2, p3, p4;
long long poww(long long x, long long nn) {
  long long res = 1;
  while (nn) {
    if (nn & 1) res = res * x % mod;
    x = x * x % mod;
    nn >>= 1;
  }
  return res;
}
int g[N][N];
void gauss() {
  int len = r * 2;
  for (int i = 1; i <= pt.size(); i++) {
    long long inv = poww(g[i][i], mod - 2);
    for (int j = i + 1, tot1 = 0; j <= pt.size() && tot1 <= len; j++, tot1++) {
      long long P = inv * g[j][i] % mod;
      if (P) {
        for (int k = i, tot2 = 0; k <= pt.size() && tot2 <= len; k++, tot2++)
          g[j][k] = (g[j][k] - P * g[i][k] % mod) % mod;
        g[j][0] = (g[j][0] - P * g[i][0] % mod) % mod;
      }
    }
  }
  for (int i = pt.size(), low = id[0 + 50][0 + 50]; i >= low; i--) {
    g[i][0] = 1ll * g[i][0] * poww(g[i][i], mod - 2) % mod;
    for (int j = i - 1; j >= low; j--)
      g[j][0] = (g[j][0] - 1ll * g[j][i] * g[i][0] % mod) % mod;
  }
}
int main() {
  cin >> r >> p1 >> p2 >> p3 >> p4;
  long long sum = poww((p1 + p2 + p3 + p4) % mod, mod - 2);
  p1 = p1 * sum % mod;
  p2 = p2 * sum % mod;
  p3 = p3 * sum % mod;
  p4 = p4 * sum % mod;
  for (int x = r; x >= -r; x--)
    for (int y = -r; y <= r; y++)
      if (sq(x, y) <= r) {
        pt.push_back(make_pair(x, y));
        id[x + 50][y + 50] = pt.size();
      }
  for (int x = r; x >= -r; x--)
    for (int y = -r; y <= r; y++) {
      int f = id[x + 50][y + 50];
      if (!f) continue;
      g[f][f] = g[f][0] = -1;
      if (id[x - 1 + 50][y + 50]) g[f][id[x - 1 + 50][y + 50]] = p1;
      if (id[x + 50][y - 1 + 50]) g[f][id[x + 50][y - 1 + 50]] = p2;
      if (id[x + 1 + 50][y + 50]) g[f][id[x + 1 + 50][y + 50]] = p3;
      if (id[x + 50][y + 1 + 50]) g[f][id[x + 50][y + 1 + 50]] = p4;
    }
  gauss();
  printf("%d\n", (g[id[0 + 50][0 + 50]][0] + mod) % mod);
  return 0;
}