time limit per test2.5 seconds

memory limit per test256 megabytes

inputstandard input

outputstandard output

One tradition of welcoming the New Year is launching fireworks into the sky. Usually a launched firework flies vertically upward for some period of time, then explodes, splitting into several parts flying in different directions. Sometimes those parts also explode after some period of time, splitting into even more parts, and so on.

Limak, who lives in an infinite grid, has a single firework. The behaviour of the firework is described with a recursion depth n and a duration for each level of recursion t1, t2, …, tn. Once Limak launches the firework in some cell, the firework starts moving upward. After covering t1 cells (including the starting cell), it explodes and splits into two parts, each moving in the direction changed by 45 degrees (see the pictures below for clarification). So, one part moves in the top-left direction, while the other one moves in the top-right direction. Each part explodes again after covering t2 cells, splitting into two parts moving in directions again changed by 45 degrees. The process continues till the n-th level of recursion, when all 2n - 1 existing parts explode and disappear without creating new parts. After a few levels of recursion, it’s possible that some parts will be at the same place and at the same time — it is allowed and such parts do not crash.

Before launching the firework, Limak must make sure that nobody stands in cells which will be visited at least once by the firework. Can you count the number of those cells?

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 30) — the total depth of the recursion.

The second line contains n integers t1, t2, …, tn (1 ≤ ti ≤ 5). On the i-th level each of 2i - 1 parts will cover ti cells before exploding.

Output

Print one integer, denoting the number of cells which will be visited at least once by any part of the firework.

Examples

input

4

4 2 2 3

output

39

input

6

1 1 1 1 1 3

output

85

input

1

3

output

3

Note

For the first sample, the drawings below show the situation after each level of recursion. Limak launched the firework from the bottom-most red cell. It covered t1 = 4 cells (marked red), exploded and divided into two parts (their further movement is marked green). All explosions are marked with an ‘X’ character. On the last drawing, there are 4 red, 4 green, 8 orange and 23 pink cells. So, the total number of visited cells is 4 + 4 + 8 + 23 = 39.

For the second sample, the drawings below show the situation after levels 4, 5 and 6. The middle drawing shows directions of all parts that will move in the next level.

【题目链接】:http://codeforces.com/contest/750/problem/D

【题解】



记忆化搜索;

如果烟花是一直朝着一个方向放的话,最高到达的位置是5*30=150

每个点作为爆炸点，是否爆炸过;

显然在不同时刻同一坐标爆炸的效果是不同的;

则

用

bo[MAXN][300][300][10]这样的bool数组进行判重工作;

第一维是当前处理的是第几个爆炸

接下来第2和第3维表示在哪一个点发生的爆炸;

第4维表示的是爆炸的延续方向;

进行这样一次爆炸过后把这个bool设置为true;

下次就不会重复工作了

可以发现爆炸的方向规律就是当前的位置中八个相邻的位置;

当前的爆炸方向的相邻方向;

所以const dx,dy那个方向数组一定要是顺时针或逆时针按顺序排的;

不然WA死.



【完整代码】

#include <bits/stdc++.h>

using namespace std;

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

#define LL long long

#define rep1(i,a,b) for (int i = a;i <= b;i++)

#define rep2(i,a,b) for (int i = a;i >= b;i--)

#define mp make_pair

#define pb push_back

#define fi first

#define se second

#define rei(x) scanf("%d",&x)

#define rel(x) scanf("%I64d",&x)

typedef pair<int,int> pii;

typedef pair<LL,LL> pll;

const int MAXN = 30+10;

const int dx[8] = {1,1,0,-1,-1,-1,0,1};

const int dy[8] = {0,1,1,1,0,-1,-1,-1};

const double pi = acos(-1.0);

int n,t[MAXN],ans = 0;

bool color[400][400];

bool vis[MAXN][400][400][10];

void dfs(int now,int x,int y,int d)

{

    if (vis[now][x][y][d]==1)

        return;

    vis[now][x][y][d] = 1;

    if (!color[x][y])

    {

        color[x][y] = 1;

        ans++;

    }

    int tx = x,ty = y;

    rep1(i,1,t[now]-1)

    {

        tx+=dx[d],ty+=dy[d];

        if (!color[tx][ty])

        {

            color[tx][ty] = 1;

            ans++;

        }

    }

    if (now == n)

        return;

    //

    int td = (d+1)%8;

    dfs(now+1,tx+dx[td],ty+dy[td],td);

    //

    td = (d+7)%8;

    dfs(now+1,tx+dx[td],ty+dy[td],td);

}

int main()

{

    //freopen("F:\\rush.txt","r",stdin);

    rei(n);

    rep1(i,1,n)

        rei(t[i]);

    dfs(1,200,200,0);

    printf("%d\n",ans);

    return 0;

}