Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.

Petya decided to introduce the sum operation on the set of permutations of length n. Let's assume that we are given two permutations of length n: a1, a2, ..., an and b1, b2, ..., bn. Petya calls the sum of permutations a and b such permutation c of length n, where ci = ((ai - 1 + bi - 1) mod n) + 1 (1 ≤ i ≤ n).

Operation <image> means taking the remainder after dividing number x by number y.

Obviously, not for all permutations a and b exists permutation c that is sum of a and b. That's why Petya got sad and asked you to do the following: given n, count the number of such pairs of permutations a and b of length n, that exists permutation c that is sum of a and b. The pair of permutations x, y (x ≠ y) and the pair of permutations y, x are considered distinct pairs.

As the answer can be rather large, print the remainder after dividing it by 1000000007 (109 + 7).

Input

The single line contains integer n (1 ≤ n ≤ 16).

Output

In the single line print a single non-negative integer — the number of such pairs of permutations a and b, that exists permutation c that is sum of a and b, modulo 1000000007 (109 + 7).

Examples

Input

3


Output

18


Input

5


Output

1800
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					long prevTime = System.currentTimeMillis();
					new Main().run();
					System.err.println("Total time: "
							+ (System.currentTimeMillis() - prevTime) + " ms");
					System.err.println("Memory status: " + memoryStatus());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start();
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		Object o = solve();
		if (o != null)
			out.println(o);
		out.close();
		in.close();
	}
	int MOD = 1000000007;
	private Object solve() throws IOException {
//		int[] ans = new int[17];
//		for(int i =1;i<=16;i++)
//			ans[i]= solve2(i);
		int[] ans = {0, 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0};
		return ans[ni()];
	}

	private int solve2(int n) throws IOException {
		if(n%2==0)
			return 0;
		List<Integer>[] list_bits = (List<Integer>[]) new List[n+1];
		for(int i =0;i<=n;i++)
			list_bits[i]= new ArrayList<Integer>();
		for(int mask=0;mask< (1<<n);mask++)
			list_bits[Integer.bitCount(mask)].add(mask);
		int[][] bits = new int[n+1][];
		for(int i =0;i<=n;i++){
			bits[i]= new int[list_bits[i].size()];
			for(int j =0;j<list_bits[i].size();j++)
				bits[i][j]= list_bits[i].get(j);
		}
		int[][] actual = new int[bits[n/2].length][bits[n/2].length];
		actual[0][0]=1;
		
		int[][] next = new int[bits[n/2].length][bits[n/2].length];
		
		for(int k =0;k<n;k++){
			
			
			for(int index =0;index<bits[k].length;index++){
				int usado = bits[k][index];					//usados
				for(int a =0;a<n;a++)
					if((usado| (1<<a) )!=usado){
						int new_usado = (1<<a)+usado;			//nuevo usado
						int b= (a+k)%n;
						for(int c = 0; c< bits[k].length;c++){
							int obtenido = bits[k][c];
							if(((1<<b) |  obtenido )!=obtenido){
								int new_obtenido= (1<<b) |  obtenido;
								int index_usado = Arrays.binarySearch(bits[k+1], new_usado);
								int index_obtenido= Arrays.binarySearch(bits[k+1], new_obtenido);
								
								next[index_usado][index_obtenido]=(next[index_usado][index_obtenido]+actual[index][c])%MOD;
							}
						}
					}
			}
			int[][] t = actual;
			actual = next;
			next=t;
			clear(next);
			
		}
		long ret = actual[0][0];
		for(long i =1;i<=n;i++)
			ret = (ret* i )%MOD;
		
		return (int) ret;
	}

	private void clear(int[][] matrix) {
		for(int i =0;i<matrix.length;i++)
			for(int j =0;j<matrix[0].length;j++)
				matrix[i][j]=0;
		
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	int ni() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nl() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nd() throws IOException {
		return Double.parseDouble(nextToken());
	}

	int[] nia(int size) throws IOException {
		int[] ret = new int[size];
		for (int i = 0; i < size; i++)
			ret[i] = ni();
		return ret;
	}

	long[] nla(int size) throws IOException {
		long[] ret = new long[size];
		for (int i = 0; i < size; i++)
			ret[i] = nl();
		return ret;
	}

	double[] nda(int size) throws IOException {
		double[] ret = new double[size];
		for (int i = 0; i < size; i++)
			ret[i] = nd();
		return ret;
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}

	void printRepeat(String s, int count) {
		for (int i = 0; i < count; i++)
			out.print(s);
	}

	void printArray(int[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(long[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(double[] array) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(double[] array, String spec) {
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				out.print(' ');
			out.printf(Locale.US, spec, array[i]);
		}
		out.println();
	}

	void printArray(Object[] array) {
		boolean blank = false;
		for (Object x : array) {
			if (blank)
				out.print(' ');
			else
				blank = true;
			out.print(x);
		}
		out.println();
	}

	@SuppressWarnings("rawtypes")
	void printCollection(Collection collection) {
		boolean blank = false;
		for (Object x : collection) {
			if (blank)
				out.print(' ');
			else
				blank = true;
			out.print(x);
		}
		out.println();
	}

	static String memoryStatus() {
		return (Runtime.getRuntime().totalMemory()
				- Runtime.getRuntime().freeMemory() >> 20)
				+ "/" + (Runtime.getRuntime().totalMemory() >> 20) + " MB";
	}
}