Problem: A robot is standing at the origin of the infinite two-dimensional plane. Each second the robot moves exactly 1 meter in one of the four cardinal directions: north, south, west, and east. For the first step the robot can choose any of the four directions, but then at the end of every second it has to turn 90 degrees left or right with respect to the direction it just moved in. For example, if the robot has just moved north or south, the next step it takes has to be either west or east, and vice versa.

The robot makes exactly n steps from its starting position according to the rules above. How many different points can the robot arrive to at the end? The final orientation of the robot can be ignored.

Input

The only line contains a single integer n (1 ≤ n ≤ 1000) — the number of steps the robot makes.

Output

Print a single integer — the number of different possible locations after exactly n steps.

Examples

Input


1


Output


4


Input


2


Output


4


Input


3


Output


12

Note

In the first sample case, the robot will end up 1 meter north, south, west, or east depending on its initial direction.

In the second sample case, the robot will always end up √{2} meters north-west, north-east, south-west, or south-east.

Solution (in CPP):

Solution:
//@Author: zwu2019015098
//@Date: 2020/12/19
#pragma GCC optimize(3, "Ofast", "inline")
/*
#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
#include <utility>
#include <map>
#include <set>
#include <cstring>
#include <string>
#include <cstdlib>
*/
#include <bits/stdc++.h>
using namespace std;

#define len(s) (s).size()
#define all(v) (v).begin(), (v).end()
#define rng(v) reverse((v).begin(), (v).end())
#define rall(v) (v).begin(), (v).end()
#define print(n) cout << n << '\n'
#define mem(a, b) memset(a, b, sizeof(a))

#define rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define per(i, a, b) for(int i = (a); i >= (b); --i)
#define rep2(i, a, b) for(int i = (a); i < (b); ++i)

typedef string str;
typedef long long ll;
typedef pair<int, int> pii;

template<typename T> 
ostream& operator <<(ostream &os, const vector<T> &V) {
    os << '[';
    for (int i = 0; i < V.size(); i++) {
        os << V[i];
        if (i + 1 != V.size()) os << ", ";
        else os << ']';
    }
    return os;
}
template<typename T> 
ostream& operator <<(ostream &os, const set<T> &S) {
    os << '[';
    for (auto it = S.begin(); it != S.end(); it++) {
        os << *it;
        it++;
        if (it != S.end()) os << ", ";
        it--;
    }
    os << ']';
    return os;
}
template <typename A, typename B>
ostream& operator <<(ostream &os, const pair<A, B> &P) {
    os << '(' << P.first << ", " << P.second << ')' << '\n';
    return os;
}
template<typename A, typename B> 
ostream& operator <<(ostream &os, const map<A, B> &M) {
    os << '[';
    for (auto it = M.begin(); it != M.end(); it++) {
        os << '(' << it -> first << ", " << it -> second << ')';
        it++;
        if (it != M.end()) os << ", ";
        it--;
    }
    os << ']';
    return os;
}

inline long long read() {
    int sgn = 1; 
    long long cnt = 0;  
    char ch = getchar();
    while ('0' > ch || ch > '9') { 
        if (ch == '-') 
            sgn = -sgn; 
        ch = getchar(); 
    }
    while ('0' <= ch && ch <= '9') { 
        cnt = (cnt << 3) + (cnt << 1) + (ch ^ 48); 
        ch = getchar();
    }
    return sgn * cnt;
}
inline void put(long long n) {
    if (n < 0) { 
        putchar('-'); 
        n = -n; 
    }
    if (n > 9) put(n / 10);
    putchar(n % 10 + '0');
}

const int MAXN = 2e3 + 5;
int dic[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };

int n, ans;

bool vis[MAXN][MAXN];
struct node {
    int x, y, dir, step;
    node(int x, int y, int dir, int step) : x(x), y(y), dir(dir), step(step) {}
};
void bfs(int x, int y){  
    mem(vis, false);
    queue<node> Q; Q.push(node(x, y, -1, 0)); //vis[x][y] = true;
    while (!Q.empty()) {
        node now = Q.front(); Q.pop();
        int x = now.x, y = now.y, dir = now.dir, step = now.step;
        //cout << x << ' ' << y << ' ' << dir << ' ' << step << endl;
        if (step > n) continue;
        if (step == n) {
            if (vis[x][y]) continue;
            vis[x][y] = true;
            ans++; 
        }
        if (dir == -1) {
            rep2 (i, 0, 4) {
                int nx = x + dic[i][0];
                int ny = y + dic[i][1];
                if (nx == x) Q.push(node(nx, ny, 1, step + 1));
                else Q.push(node(nx, ny, 0, step + 1));
            }
        } else if (dir == 1) {
            Q.push(node(x - 1, y, 0, step + 1));
            Q.push(node(x + 1, y, 0, step + 1));
        } else if (dir == 0) {
            Q.push(node(x, y - 1, 1, step + 1));
            Q.push(node(x, y + 1, 1, step + 1));
        }
    }
}

/*
int dp[MAXN][MAXN];
int dfs(int x, int y, int dic, int step) {
    if (step > n) return 0;
    //if (dp[x][y]) return dp[x][y];
    if (step == n) return 1;
    if (dic == -1) {
        rep2 (i, 0, 4) {
            int nx = x + dir[i][0];
            int ny = y + dir[i][1];
            if (nx == x) dp[x][y] += dfs(nx, ny, 1, step + 1);
            else dp[x][y] += dfs(nx, ny, 0, step + 1);
        }
    } else if (dic == 1) {
        rep (i, -1, 1) {
            if (i == 0) continue;
            int nx = x + i;
            int ny = y;
            dp[x][y] += dfs(nx, ny, 0, step + 1);
        }
    } else {
        rep (i, -1, 1) {
            if (i == 0) continue;
            int nx = x;
            int ny = y + i;
            dp[x][y] += dfs(nx, ny, 1, step + 1);
        }
    }
    return dp[x][y];
}
*/
int main(int argc, char *argv[]){  
    int n = read();
    if (n % 2 == 0) {
        int k = n / 2 + 1;
        print(k * k);
    } else {
        int k = n / 2 + 1;
        if (n == 1) print(4);
        else {
            int tmp = 1, d = 2;
            rep (i, 2, k) {
                tmp += d;
                d++;
            }
            print(tmp * 4);
        }
        
    }
    //system("pause");  // do not use in codeforces
    return 0;  
}