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>.
#include <bits/stdc++.h>
using namespace std;
const vector<int> dx = {-1, 0, 1, 0};
const vector<int> dy = {0, -1, 0, 1};
const int md = (int)1e9 + 7;
inline void sub(int &x, int y) {
  x -= y;
  if (x < 0) x += md;
}
inline int mul(int x, int y) { return (int)((long long)x * y % md); }
inline int inv(int a) {
  int b = md, u = 0, v = 1;
  while (a) {
    int t = b / a;
    b -= t * a;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  if (u < 0) u += md;
  return u;
}
int main() {
  int r;
  cin >> r;
  vector<int> p(4);
  for (int i = 0; i < 4; ++i) cin >> p[i];
  int sum_p = 0;
  for (int i = 0; i < 4; ++i) sum_p += p[i];
  int inv_sum_p = inv(sum_p);
  for (int i = 0; i < 4; ++i) p[i] = mul(p[i], inv_sum_p);
  int d = r * 2 + 1, n = 0;
  vector<vector<int>> id(d, vector<int>(d, -1));
  for (int i = 0; i < d; ++i)
    for (int j = 0; j < d; ++j)
      if ((i - r) * (i - r) + (j - r) * (j - r) <= r * r) id[i][j] = n++;
  vector<vector<int>> equation(n, vector<int>(n));
  vector<int> weight(n);
  for (int i = 0; i < d; ++i)
    for (int j = 0; j < d; ++j)
      if (id[i][j] != -1) {
        equation[id[i][j]][id[i][j]] = weight[id[i][j]] = md - 1;
        for (int k = 0; k < 4; ++k) {
          int ii = i + dx[k], jj = j + dy[k];
          if (ii >= 0 && ii < d && jj >= 0 && jj < d && id[ii][jj] != -1)
            equation[id[i][j]][id[ii][jj]] = p[k];
        }
      }
  for (int i = 0; i < n; ++i) {
    assert(equation[i][i] != 0);
    int inv_value = inv(equation[i][i]);
    for (int j = i + 1; j < min(n, i + d); ++j)
      if (equation[j][i]) {
        int coef = mul(equation[j][i], inv_value);
        for (int k = i; k < min(n, i + d); ++k)
          sub(equation[j][k], mul(equation[i][k], coef));
        sub(weight[j], mul(weight[i], coef));
      }
  }
  vector<int> ans(n);
  for (int i = n - 1; ~i; --i) {
    ans[i] = weight[i];
    for (int j = i + 1; j < n; ++j) sub(ans[i], mul(ans[j], equation[i][j]));
    ans[i] = mul(ans[i], inv(equation[i][i]));
  }
  cout << ans[id[r][r]] << "\n";
  return 0;
}
