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 = 1000000007;
inline int quick_pow(int a, int b) {
  int res = 1;
  while (b) {
    if (b & 1) res = 1ll * res * a % mod;
    a = 1ll * a * a % mod;
    b >>= 1;
  }
  return res;
}
int R, p1, p2, p3, p4;
struct Node {
  int k[105], b;
  inline Node() {
    memset(k, 0, sizeof(k));
    b = 0;
  }
  Node operator+(const Node &oth) const {
    Node res;
    for (int i = 0; i <= 2 * R; i++) res.k[i] = (k[i] + oth.k[i]) % mod;
    res.b = (b + oth.b) % mod;
    return res;
  }
  Node operator+(const int &c) const {
    Node res = *this;
    res.b = (res.b + c) % mod;
    return res;
  }
  Node operator*(const int &c) const {
    Node res = *this;
    for (int i = 0; i <= 2 * R; i++) res.k[i] = 1ll * res.k[i] * c % mod;
    res.b = 1ll * res.b * c % mod;
    return res;
  }
} a[105][105];
int range[105], X[105];
vector<Node> equ;
int main() {
  scanf("%d%d%d%d%d", &R, &p1, &p2, &p3, &p4);
  int inv = quick_pow(p1 + p2 + p3 + p4, mod - 2);
  p1 = 1ll * p1 * inv % mod;
  p2 = 1ll * p2 * inv % mod;
  p3 = 1ll * p3 * inv % mod;
  p4 = 1ll * p4 * inv % mod;
  int invp4 = quick_pow(p4, mod - 2);
  for (int i = -R; i <= R; i++) {
    for (int j = R; j >= 0; j--) {
      if (i * i + j * j <= R * R) {
        range[i + R] = j;
        break;
      }
    }
    a[i + R][-range[i + R] + R].k[i + R] = 1;
  }
  for (int j = -R; j <= R; j++) {
    for (int i = -range[j + R]; i <= range[j + R]; i++) {
      a[i + R][j + R + 1] = a[i + R][j + R] + (mod - 1);
      if (i - 1 + R >= 0)
        a[i + R][j + R + 1] =
            a[i + R][j + R + 1] + (a[i - 1 + R][j + R] * (mod - p1));
      if (j - 1 + R >= 0)
        a[i + R][j + R + 1] =
            a[i + R][j + R + 1] + (a[i + R][j - 1 + R] * (mod - p2));
      a[i + R][j + R + 1] =
          a[i + R][j + R + 1] + (a[i + 1 + R][j + R] * (mod - p3));
      a[i + R][j + R + 1] = a[i + R][j + R + 1] * invp4;
      if (i * i + (j + 1) * (j + 1) > R * R) equ.push_back(a[i + R][j + 1 + R]);
    }
  }
  for (int i = 0, j, k; i <= 2 * R; i++) {
    for (j = i; j <= 2 * R; j++)
      if (equ[j].k[i]) break;
    if (j != i) {
      for (k = i; k <= 2 * R; k++) swap(equ[i].k[k], equ[j].k[k]);
      swap(equ[i].b, equ[j].b);
    }
    int tmpinv = quick_pow(equ[i].k[i], mod - 2);
    for (j = 0; j <= 2 * R; j++)
      if (j != i && equ[j].k[i]) {
        int coef = 1ll * tmpinv * (mod - equ[j].k[i]) % mod;
        for (int k = i; k <= 2 * R; k++)
          equ[j].k[k] = (equ[j].k[k] + 1ll * coef * equ[i].k[k] % mod) % mod;
        equ[j].b = (equ[j].b + 1ll * coef * equ[i].b % mod) % mod;
      }
  }
  for (int i = 0; i <= 2 * R; i++)
    X[i] = 1ll * quick_pow(equ[i].k[i], mod - 2) * (mod - equ[i].b) % mod;
  int ans = a[R][R].b;
  for (int i = 0; i <= 2 * R; i++)
    ans = (ans + 1ll * a[R][R].k[i] * X[i] % mod) % mod;
  printf("%d\n", ans);
  return 0;
}