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.*;
import java.util.*;
import static java.lang.Math.*;
public class ProblemD {
	int N;
	long P = 1000000007;
	//Map<Integer,Long> cache = new HashMap<Integer,Long>();
	
	int[] answers = {
		0, 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0
	};

    void run() {
        FastScanner sc = new FastScanner(System.in);
		N = sc.nextInt();

		p("%d\n", answers[N]);

		//int used = 0;
		//int num_used = 0;
		//int to_use = (1 << N) - 1;
		//long answer = solve(used, num_used, to_use);
		//for (int i = 1; i <= N; ++i) {
		//	answer = (answer * i) % P;
		//}
		//p("%d\n", answer);
    }

	// num_used just for convenience, should be number of bits
	// turned on in used
	long solve(int used, int num_used, int to_use) {
		//int p = pack(used, to_use);
		//if (cache.containsKey(p)){
			//return cache.get(p);
		//}
		if (to_use == 0) {
			return 1;
		}
		long answer = 0;
		for (int i = 0; i < N; ++i) {
			// check still have i left to use
			if (((1 << i) & to_use) > 0) {
				// check it will add a new a_i + b_i
				int sum = (i + num_used) % N;
				if (((1 << sum) & used) == 0) {
					int new_used = (1 << sum) | used;
					int new_num_used = num_used + 1;
					int new_to_use = (1 << i) ^ to_use;
					answer += solve(new_used, new_num_used, new_to_use);
				}
			}
		}
		//cache.put(p, answer);
		return answer;
	}

	// pack / unpack two 16 bit integers
	int pack(int x, int y) {
		 return (x << 16) | y;
	}

    boolean debug = false;
    void p(String f, Object...params) {
        System.out.printf(f, params);
    }
    void d(Object...params) {
        if (debug) {
            p("DEBUG: %s\n", Arrays.deepToString(params));
        }
    }
    static void die() {
        throw new RuntimeException();
    }
    void timeout() {
        for (int x = 0; ; ++x);
    }
    public ProblemD(String[] args) {
        if (args.length > 0 && args[0].equals("debug")) {
            debug = true;
        }
    }
    public static void main(String[] args) {
        new ProblemD(args).run();
    }

    private static class FastScanner {
      private BufferedReader in;
      private StringTokenizer tok;
      public FastScanner(InputStream inputstream) {
        in = new BufferedReader(new InputStreamReader(inputstream));
        tok = null;
      }
      private void tokenizeLine() {
        try {
          String line = in.readLine();
          if (line == null) die();
          tok = new StringTokenizer(line);
        } catch (IOException e) {
          die();
        }
      }
      public String next() {
        while (tok == null || !tok.hasMoreTokens()) {
          tokenizeLine();
        }
        return tok.nextToken();
      }
      public boolean hasNextLine() {
        if (tok == null) {
          try {
            tokenizeLine();
          }
          catch (Exception e) {
            return false;
          }
        }
        return true;
      }
      public String nextLine() {
        if (tok == null) {
          tokenizeLine();
        }
        String ret = tok.hasMoreTokens() ? tok.nextToken("\n"): "";
        tok = null;
        return ret;
      }
      public int nextInt() {
        return Integer.parseInt(next());
      }
      public long nextLong() {
        return Long.parseLong(next());
      }
      public double nextDouble() {
        return Double.parseDouble(next());
      }
    }
}
