Those unwilling to return home from a long journey, will be affected by the oddity of the snail and lose their way. Mayoi, the oddity's carrier, wouldn't like this to happen, but there's nothing to do with this before a cure is figured out. For now, she would only like to know the enormous number of possibilities to be faced with if someone gets lost.

There are n towns in the region, numbered from 1 to n. The town numbered 1 is called the capital. The traffic network is formed by bidirectional roads connecting pairs of towns. No two roads connect the same pair of towns, and no road connects a town with itself. The time needed to travel through each of the roads is the same. Lost travelers will not be able to find out how the towns are connected, but the residents can help them by providing the following facts: 

  * Starting from each town other than the capital, the shortest path (i.e. the path passing through the minimum number of roads) to the capital exists, and is unique; 
  * Let li be the number of roads on the shortest path from town i to the capital, then li ≥ li - 1 holds for all 2 ≤ i ≤ n; 
  * For town i, the number of roads connected to it is denoted by di, which equals either 2 or 3. 



You are to count the number of different ways in which the towns are connected, and give the answer modulo 109 + 7. Two ways of connecting towns are considered different if a pair (u, v) (1 ≤ u, v ≤ n) exists such there is a road between towns u and v in one of them but not in the other.

Input

The first line of input contains a positive integer n (3 ≤ n ≤ 50) — the number of towns.

The second line contains n space-separated integers d1, d2, ..., dn (2 ≤ di ≤ 3) — the number of roads connected to towns 1, 2, ..., n, respectively. It is guaranteed that the sum of di over all i is even.

Output

Output one integer — the total number of different possible ways in which the towns are connected, modulo 109 + 7.

Examples

Input

4
3 2 3 2


Output

1


Input

5
2 3 3 2 2


Output

2


Input

5
2 2 2 2 2


Output

2


Input

20
2 2 2 2 3 2 3 2 2 2 2 2 2 2 2 2 2 3 3 2


Output

82944

Note

In the first example, the following structure is the only one to satisfy the constraints, the distances from towns 2, 3, 4 to the capital are all 1.

<image>

In the second example, the following two structures satisfy the constraints.

<image>
#include <bits/stdc++.h>
using namespace std;
static const int maxn = 50 + 5;
static const int mod = 1000000007;
int n, d[maxn];
long long f[2][maxn][maxn][maxn][maxn];
int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) scanf("%d", &d[i]);
  memset(f[0], 0, sizeof f[0]);
  f[0][d[0] == 2][d[0] == 3][d[1] == 2][d[1] == 3] = 1;
  int cur = 0, next = 1;
  for (int i = 1; i < n - 1; i++) {
    memset(f[next], 0, sizeof f[next]);
    for (int p1 = 0; p1 <= n; p1++)
      for (int p2 = 0; p1 + p2 <= n; p2++)
        for (int c1 = 0; p1 + p2 + c1 <= n; c1++)
          for (int c2 = 0; p1 + p2 + c1 + c2 <= n; c2++)
            if (f[cur][p1][p2][c1][c2]) {
              long long val = f[cur][p1][p2][c1][c2];
              if (!p1 && !p2) {
                f[cur][c1][c2][0][0] = (f[cur][c1][c2][0][0] + val) % mod;
                continue;
              }
              for (int last_level = 0; last_level < 2; last_level++) {
                int last_ways;
                if (!last_level) {
                  last_ways = p1;
                  if (--p1 < 0) {
                    p1++;
                    continue;
                  }
                } else {
                  last_ways = p2;
                  if (--p2 < 0) {
                    p2++;
                    continue;
                  } else
                    p1++;
                }
                if (d[i + 1] == 2) {
                  f[next][p1][p2][c1 + 1][c2] =
                      (f[next][p1][p2][c1 + 1][c2] + val * last_ways) % mod;
                  if (c1)
                    f[next][p1][p2][c1 - 1][c2] =
                        (f[next][p1][p2][c1 - 1][c2] + val * last_ways * c1) %
                        mod;
                  if (c2)
                    f[next][p1][p2][c1 + 1][c2 - 1] =
                        (f[next][p1][p2][c1 + 1][c2 - 1] +
                         val * last_ways * c2) %
                        mod;
                } else {
                  f[next][p1][p2][c1][c2 + 1] =
                      (f[next][p1][p2][c1][c2 + 1] + val * last_ways) % mod;
                  if (c1)
                    f[next][p1][p2][c1][c2] =
                        (f[next][p1][p2][c1][c2] + val * last_ways * c1) % mod;
                  if (c2)
                    f[next][p1][p2][c1 + 2][c2 - 1] =
                        (f[next][p1][p2][c1 + 2][c2 - 1] +
                         val * last_ways * c2) %
                        mod;
                  if (c1 > 1)
                    f[next][p1][p2][c1 - 2][c2] =
                        (f[next][p1][p2][c1 - 2][c2] +
                         val * last_ways * c1 * (c1 - 1) / 2) %
                        mod;
                  if (c2 > 1)
                    f[next][p1][p2][c1 + 2][c2 - 2] =
                        (f[next][p1][p2][c1 + 2][c2 - 2] +
                         val * last_ways * c2 * (c2 - 1) / 2) %
                        mod;
                  if (c1 && c2)
                    f[next][p1][p2][c1][c2 - 1] = (f[next][p1][p2][c1][c2 - 1] +
                                                   val * last_ways * c1 * c2) %
                                                  mod;
                }
                if (!last_level)
                  p1++;
                else
                  p2++, p1--;
              }
            }
    cur ^= 1, next ^= 1;
  }
  cout << f[cur][0][0][0][0] << endl;
  return 0;
}
