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 vector<int> dx = {-1, 0, 1, 0};
const vector<int> dy = {0, -1, 0, 1};
const int mod = (int)1e9 + 7;
inline void add(int &x, int y) {
  x += y;
  if (x >= mod) x -= mod;
}
inline void sub(int &x, int y) {
  x -= y;
  if (x < 0) x += mod;
}
inline int mul(int x, int y) { return (int)((long long)x * y % mod); }
int sqr(int x) { return x * x; }
inline int inv(int a) {
  int b = mod, 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 += mod;
  return u;
}
vector<int> &operator-=(vector<int> &a, const vector<int> &b) {
  if (a.size() < b.size()) a.resize(b.size());
  for (int i = 0; i < (int)b.size(); ++i) sub(a[i], b[i]);
  return a;
}
vector<int> &operator*=(vector<int> &a, const int &b) {
  for (int i = 0; i < (int)a.size(); ++i) a[i] = mul(a[i], b);
  return a;
}
vector<int> operator*(const vector<int> &a, const int &b) {
  vector<int> c = a;
  return c *= b;
}
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 (sqr(R - i) + sqr(R - j) <= sqr(R)) id[i][j] = n++;
  vector<int> first(d, -1);
  for (int i = 0; i < d; ++i)
    for (int j = 0; j < d; ++j)
      if (id[i][j] != -1 && first[i] == -1) first[i] = j;
  vector<vector<int>> coef(n, vector<int>(d + 1));
  for (int i = 0; i < d; ++i) coef[id[i][first[i]]][i] = 1;
  vector<vector<int>> equation;
  int invp3 = inv(p[3]);
  for (int j = 0; j < d; ++j)
    for (int i = 0; i < d; ++i)
      if (id[i][j] != -1) {
        vector<int> poly = coef[id[i][j]];
        sub(poly[d], 1);
        for (int k = 0; k < 3; ++k) {
          int ii = i + dx[k], jj = j + dy[k];
          if (ii >= 0 && ii < d && jj >= 0 && jj < d && id[ii][jj] != -1)
            poly -= coef[id[ii][jj]] * p[k];
        }
        if (j + 1 == d || id[i][j + 1] == -1) {
          poly[d] = (mod - poly[d]) % mod;
          equation.push_back(poly);
        } else
          coef[id[i][j + 1]] = poly * invp3;
      }
  for (int i = 0; i < d; ++i) {
    int j = i;
    while (j < d && !equation[j][i]) ++j;
    assert(j != d);
    if (j != i) swap(equation[i], equation[j]);
    int inv_value = inv(equation[i][i]);
    for (int j = i + 1; j < d; ++j)
      if (equation[j][i])
        equation[j] -= equation[i] * mul(equation[j][i], inv_value);
  }
  vector<int> ans(d);
  for (int i = d - 1; ~i; --i) {
    ans[i] = equation[i][d];
    for (int j = i + 1; j < d; ++j) sub(ans[i], mul(ans[j], equation[i][j]));
    ans[i] = mul(ans[i], inv(equation[i][i]));
  }
  int res = coef[id[R][R]][d];
  for (int i = 0; i < d; ++i) add(res, mul(ans[i], coef[id[R][R]][i]));
  cout << res << "\n";
  return 0;
}