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 JAVA):

Solution:

import java.util.*;
import java.io.*;
import java.lang.*;

public class cfpract {
   
    public static class pair{
        int x=0,y=0;
        pair(int x,int y){this.x=x;  this.y=y; }


        // @Override
        // public boolean equals(pair obj){
        //     if(this==obj)return true;
        //     return obj.x==this.x && obj.y==this.y ;
        // }
    }

    public static ArrayList<Integer> get(int n)
    {
        ArrayList<Integer> ans=new ArrayList<>() ;
        
        for(int i = -n; i <= n; i += 2)
            ans.add(i);
     
        return ans;
    }
     
    public static int test_case(int n){
        int x = (n + 1) / 2;
        int y = n - x;
     
        ArrayList<Integer> a = get(x);
        ArrayList<Integer> b = get(y);
     
        // set<pii> s;
        // HashSet<pair> s=new HashSet<>();
        HashSet<String> s=new HashSet<>();

        for(int xi : a){
            for(int yi : b){
                s.add(xi+"&"+yi);    //V.V.V.Imp bcz to compare pair(x,y) is very difficult in hashset.So making a string I will compare pair(x,y)
            }
        }
     
        a.clear();
        b.clear();
     
        a = get(y);
        b = get(x);
     
        for(int xi : a){
            for(int yi : b){
                s.add(xi+"&"+yi);
            }
        }
        
        return s.size();
    }



    public static void solve3() throws Exception{
        InputStreamReader ip=new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ip);
        // int t = Integer.parseInt(br.readLine());
    
        int n =Integer.parseInt(br.readLine());
        System.out.println(test_case(n));
        
    }


   

    public static void sec() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] scn = (br.readLine()).trim().split(" ");
		int n = Integer.parseInt(scn[0]);
		long ans = 0;
		if (n % 2 == 1)
			ans = 1 + (3 * n * (n + 4) + 2 - (-1) * (n * (n + 4) + 2)) / 8;
		else
			ans = 1 + (3 * n * (n + 4) + 2 - (n * (n + 4) + 2)) / 8;
		System.out.println(ans);
		return;
	}

//******************************************************************************************************************** */
    public static void main(String[] args) throws Exception{
        solve3();
        // sec();
     }

     public static void solve2() throws Exception{
        InputStreamReader ip=new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ip);
        int t = Integer.parseInt(br.readLine());
        StringBuilder asb=new StringBuilder();

       while(t-->0){
        // int n =Integer.parseInt(br.readLine());
        // String[] strs=(br.readLine()).trim().split(" ");
        // int n=Integer.parseInt(strs[0]),l=Integer.parseInt(strs[1]),r=Integer.parseInt(strs[2]),s=Integer.parseInt(strs[3]);
        //  String str=(br.readLine()).trim();
        
       }
    }
    //sort
     public static void sort(long[] arr) {
		int n = arr.length;
		for (int i = 0; i < n; i++) {
			int idx = (int) Math.random() * n;
			long temp = arr[i];  arr[i] = arr[idx];  arr[idx] = temp;  //swap
		}
		Arrays.sort(arr);
	}
 
	public static void sort(int[] arr) {
		int n = arr.length;
		for (int i = 0; i < n; i++) {
			int idx = (int) Math.random() * n;
			int temp = arr[i];  arr[i] = arr[idx]; arr[idx] = temp;  //swap
		}
		Arrays.sort(arr);
	}
    //1d print
    public static void print(int[] dp) {
		for (int val : dp) {
			System.out.print(val + " ");
		}
		System.out.println();
	}
 
	public static void print(long[] dp) {
		for (long val : dp) {
			System.out.print(val + " ");
		}
		System.out.println();
	}  
    //2d print
	public static void print(long[][] dp) {
		for (long[] a : dp) {
			for (long val : a) {
				System.out.print(val + " ");
			}
			System.out.println();
		}
	}
 
	public static void print(int[][] dp) {
		for (int[] a : dp) {
			for (int val : a) {
				System.out.print(val + " ");
			}
			System.out.println();
		}
	}
 
	
}