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.
import java.io.*;
import java.util.*;

/**
    @author NTUDragons
 */
 
public class D{
    static int MAXN=500010;
    static int n;
    static int MOD= 1000000007;
    static int mod= 65536;
    static int P= 131;
    static Scanner sc= new Scanner(System.in);
    static long[] base= new long[MAXN];
    static long[] one= new long[MAXN];
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    // main solver
    static class Task{
        public void solve(InputReader in, PrintWriter out) {
            int n= in.nextInt();
            if(n%2==0){
                out.println((n/2+1)*(n/2+1));
            }
            else{
                int k=(n-1)/2;
                out.println(2*(k+1)*(k+2));
            }
            
        }
        public long gcd(long a, long b){
            a= Math.abs(a); b= Math.abs(b);
            while(b>0){
                long temp= b;
                b=a%b;
                a=temp;
            }
            return a;
        }
        public void preprocess(){
            base[0]=1;
            
            for(int i=1;i<=n;i++) {
                base[i]=base[i-1]*P%MOD;
                one[i]=(one[i-1]*P%MOD+1)%MOD;
            }
        }

        public int[][] lcs(char[] A, char[] B) {
            int n= A.length, m= B.length;
            int[][] dp= new int[n+1][m+1];

            for(int i=1;i<=n;i++) {
                for(int j=1;j<=m;j++) {
                    if(A[i-1]==B[j-1]){
                        dp[i][j]= dp[i-1][j-1]+1;
                    }
                    else {
                        dp[i][j]= Math.max(dp[i-1][j],dp[i][j-1]);
                    }
                }
            }
            return dp;
        }

        public List<Pair> dfs(int[][] dp, char[] A, char[] B) {
            int n= A.length, m= B.length;
            int i= n, j=m;
            List<Pair> l= new ArrayList<>();
            while(dp[i][j]!=0) {
                if(A[i-1]==B[j-1]) {
                    l.add(new Pair(i-1,j-1));
                    i--;j--;
                }
                else{
                    if(dp[i-1][j]>dp[i][j-1]) i--;
                    else j--;
                }
            }
            return l;
        }
    }
    static class Pair implements Comparable<Pair>{
        public int x, y;
        public Pair(int x, int y){
            this.x = x;
            this.y = y;
        }
 
        @Override
        public int compareTo(Pair o) {
            if (this.x > o.x){
                return 1;
            }
            else if (this.x < o.x){
                return -1;
            }
            else{
                return Integer.compare(this.y, o.y);
            }
        }
    }

    static class SEG{
        static class Node{
            public long val=0;
            public long max=0;
            public int l=-1,r=-1;
        }
        long[] lazy= new long[4*MAXN];
        Node[] tree= new Node[4*MAXN];
        
        
        public SEG(){
            
            build(1,1,n);
        }


        public void detectOverflow(int i){
            if(tree[i].max>=mod){
                if(tree[i].l==tree[i].r){
                    tree[i].max-= mod;
                    tree[i].val-= mod;
                    return;
                }
                push(i);
                if(tree[2*i].max>=mod) detectOverflow(2*i);
                if(tree[2*i+1].max>=mod) detectOverflow(2*i+1);
                up(i);
            }
        }

        public void up(int i){
            int len= tree[2*i+1].r-tree[2*i+1].l+1;
            tree[i].val= (tree[2*i].val*base[len]%MOD + tree[2*i+1].val)%MOD;
            tree[i].max= Math.max(tree[2*i].max, tree[2*i+1].max);
        }

        public void build(int i, int l, int r){
            tree[i]= new Node();
            tree[i].l=l;tree[i].r=r;
            if(l==r){
                tree[i].val=sc.nextInt();
                tree[i].max= tree[i].val;
            }
            else{
                int mid= (l+r)>>1;
                build(2*i,l,mid);
                build(2*i+1,mid+1,r);
                up(i);
            }
        }

        public void update(int i, int l, int r){
            if(l<=tree[i].l && r>= tree[i].r){
                lazy[i]++;
                tree[i].max++;
                int len= tree[i].r- tree[i].l+1;
                tree[i].val= (tree[i].val+one[len])%MOD;
                return;
            }
            else{
                push(i);
                int mid= (tree[i].l+tree[i].r) >>1;
                if(l<=mid) update(2*i,l,r);
                if(r>mid) update(2*i+1,l,r);
                up(i);
            }
        }

        public void push(int i){
            if(lazy[i]!=0){
                int ll= tree[2*i].r-tree[2*i].l+1;
                int lr= tree[2*i+1].r-tree[2*i+1].l+1;
                tree[2*i].max+= lazy[i];
                tree[2*i+1].max+= lazy[i];
                tree[2*i].val= (tree[2*i].val+lazy[i]*one[ll]%MOD)%MOD;
                tree[2*i+1].val= (tree[2*i+1].val+lazy[i]*one[lr]%MOD)%MOD;

                lazy[2*i]+=lazy[i];lazy[2*i+1]+=lazy[i];
                lazy[i]=0;
            }
        }

        public long get(int i, int l, int r){
            if(l<=tree[i].l && r>= tree[i].r) return tree[i].val;
            push(i);
            int mid= (tree[i].l+tree[i].r)>>1;
            long ans=0;
            if(r<=mid) ans= get(2*i,l,r);
            else if(l>mid) ans= get(2*i+1,l,r);
            else ans= (get(2*i,l,mid)*base[r-mid]%MOD + get(2*i+1,mid+1,r))%MOD;
            return ans;
        }

    }
    // fast input reader class;
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;
 
        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
        }
 
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                String line = null;
                try {
                    line = br.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (line == null) {
                    return null;
                }
                st = new StringTokenizer(line);
            }
            return st.nextToken();
        }
 
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        public double nextDouble(){
            return Double.parseDouble(nextToken());
        }
        public long nextLong(){
            return Long.parseLong(nextToken());
        }
    }
}