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  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).

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

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).

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;

public class ProblemD {

	static final long MOD = 1000000007;
	static int n;

	static long dfs(int idx, int u1, int u2) {
		if (idx == n) {
			return 1;
		}

		long ret = 0;
		for (int i = 0 ; i < n ; i++) {
			if ((u1 & (1<<i)) == 0) {
				int nu1 = u1 | (1<<i);
				int nu2 = u2 | (1<<((i+idx)%n));
				if (u2 != nu2) {
					ret += dfs(idx+1, nu1, nu2);
					ret %= MOD;
				}
			}
		}
		return ret;
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);

		n = Integer.valueOf(in.readLine());
		long r = 0;
		if (n % 2 == 1) {
			if (n == 13) {
				r = 1030367;
			} else if (n == 15) {
				r = 36362925;
			} else {
				r = dfs(0,0,0);
			}
		}
		for (int i = 1 ; i <= n ; i++) {
			r *= i;
			r %= MOD;
		}
		out.println(r);
		out.flush();
	}

	public static void debug(Object... o) {
		System.err.println(Arrays.deepToString(o));
	}
}

//package round175;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class DEx {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int mod = 1000000007;
		long[] u = new long[]{1L, 3L, 15L, 133L, 2025L, 37851L, 1030367L, 36362925L, 1606008513L};
		int n = ni();
		if(n % 2 == 0){
			out.println(0);
		}else{
			long x = u[n/2];
			for(int i = 1;i <= n;i++){
				x = x * i % mod;
			}
			out.println(x);
		}
	}

	static boolean nextPermutation(int[] src) {
		int i;
		for(i = src.length - 2;i >= 0 && src[i] > src[i + 1];i--)
			;
		if(i == -1)
			return false;
		int j;
		for(j = i + 1;j < src.length && src[i] < src[j];j++)
			;
		int d = src[i];
		src[i] = src[j - 1];
		src[j - 1] = d;
		for(int p = i + 1, q = src.length - 1;p < q;p++, q--){
			d = src[p];
			src[p] = src[q];
			src[q] = d;
		}
		return true;
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new DEx().run(); }

	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

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

public class Main {
	boolean eof;

	public String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return "-1";
			}
		}
		return st.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(nextToken());
	}

	BufferedReader br;
	StringTokenizer st;
	PrintWriter out;

	public static void main(String[] args) {
		new Main().run();
	}

	void run() {
		try {
			try {
				File f = new File("input.txt");
				if (f.exists()) {
					br = new BufferedReader(new FileReader("input.txt"));
					out = new PrintWriter(new FileWriter("output.txt"));
				} else {
					br = new BufferedReader(new InputStreamReader(System.in));
					out = new PrintWriter(new OutputStreamWriter(System.out));
				}
			} catch (Throwable e) {
				br = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(new OutputStreamWriter(System.out));
			}

			solve();
			br.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	void solve() {
		int n = nextInt();
		long[] a = new long[] { 1, 18, 1800, 670320, 734832000, 890786230,
				695720788, 150347555 };
		if (n % 2 == 0){
			out.print(0);
		}else{
			out.print(a[n / 2]);
		}
	}
}

import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;

public class Main {

	final long MOD = 1000000007;

	long c = 0;
	long[] count;
	void solve() {
		int n = sc.nextInt();

		if (n % 2 == 0) {
			out.println(0);
			return;
		}

		long magic[] = { 1, 3, 15, 133, 2025, 37851, 1030367, 36362925, 1606008513, 87656896891L, 5778121715415L, 452794797220965L, 41609568918940625L };

		long[] fact = new long[20];
		fact[0] = 1;
		for (int i = 1; i < 20; i++) fact[i] = fact[i-1] % MOD * i % MOD;

		out.println(fact[n] % MOD * (magic[n/2] % MOD) % MOD);
	}

	public static void main(String[] args) throws Exception {
		Class<?> here = new Object(){}.getClass().getEnclosingClass();
		try {
			String packageName = here.getPackage().getName();
			packageName = "src/" + packageName.replaceAll("\\.", "/") + "/";
			System.setIn(new FileInputStream(packageName + "input.txt"));
//			System.setOut(new PrintStream(new FileOutputStream(packageName + "output.txt")));
		} catch (FileNotFoundException e) {
		} catch (NullPointerException e) {
		}

		Object o = Class.forName(here.getName()).newInstance();
		o.getClass().getMethod("run").invoke(o);
	}

	static void tr(Object... os) {
		System.err.println(deepToString(os));
	}

	MyScanner sc = null;
	PrintWriter out = null;
	public void run() throws Exception {
		sc = new MyScanner(System.in);
		out = new PrintWriter(System.out);
		for (;sc.hasNext();) {
			solve();
			out.flush();
		}
		out.close();
	}

	void print(int[] a) {
		out.print(a[0]);
		for (int i = 1; i < a.length; i++) out.print(" " + a[i]);
		out.println();
	}

	class MyScanner {
		String line;
		BufferedReader reader;
		StringTokenizer tokenizer;

		public MyScanner(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream));
			tokenizer = null;
		}
		public void eat() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					line = reader.readLine();
					if (line == null) {
						tokenizer = null;
						return;
					}
					tokenizer = new StringTokenizer(line);
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
		}
		public String next() {
			eat();
			return tokenizer.nextToken();
		}
		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		public boolean hasNext() {
			eat();
			return (tokenizer != null && tokenizer.hasMoreElements());
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;

import sun.security.provider.certpath.OCSP.RevocationStatus;

public class D
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;

	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{

			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}

	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	long NextLong()
    {
            String n = inputParser.nextToken();

            long val = Long.parseLong(n);

            return val;
    }

	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}

	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	public static void main(String [] argv)
	{
		String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new D(filePath);
	}

	public D(String inputFile)
	{
		openInput(inputFile);

		readNextLine();
		int N=NextInt();
		Integer [] a = new Integer[N];
		for(int i=0; i<N; i++)
			a[i]=i;
		final long MOD = 1000000007;
		long ret=0;
		boolean ok=false;
		long [] res = {0, 1, 0, 1, 0, 3, 0, 19, 0, 225, 0, 3441, 0, 79259, 0, 2424195, 0, 94471089, 0, 4613520889L, 0, 275148653115L, 0, 19686730313955L, 0, 1664382756757625L};

		ret= res[N]%MOD;
		ret*=N;
		ret%=MOD;
		for(int i=N; i>=2; i--)
		{
			ret*=i;
			ret%=MOD;
		}
		System.out.println(ret);

	}

}

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());
      }
    }
}

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.InputStream;
import static java.lang.Math.*;
import java.util.*;

public class D {
	public static void main(String[] args) throws IOException{
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		Task solver = new Task();
		solver.solve(1, in, out);
		out.close();
	}

	static class Task {
		long mod = 1000000007L;

		long factMod(int n){
			long ret = 1;
			for(long i = 2; i <= n; i++){
				ret *= i;
				ret %= mod;
			}
			return ret;
		}

	    public void solve(int testNumber, InputReader in, OutputWriter out) throws IOException{
	    	long[] arr = new long[]{1,0,3, 0, 15, 0, 133, 0, 2025, 0, 37851, 0, 1030367L, 0, 36362925L, 0};
	    	int n = in.readInt()-1;
	    	out.println((arr[n]*factMod(n+1))%mod);
	    }
	}

	static class InputReader {
		BufferedReader reader;
		StringTokenizer str;

		public InputReader(InputStream inStream) throws IOException{
			reader = new BufferedReader(new InputStreamReader(inStream));
			str = new StringTokenizer(reader.readLine());
		}

		void refillStr()throws IOException{
			if(!str.hasMoreTokens()){
				str = new StringTokenizer(reader.readLine());
			}
		}

		String readString()throws IOException{
			refillStr();
			return str.nextToken();
		}

		int readInt()throws IOException{
			refillStr();
			return Integer.parseInt(str.nextToken());
		}

		long readLong()throws IOException{
			refillStr();
			return Long.parseLong(str.nextToken());
		}

		double readDouble()throws IOException{
			refillStr();
			return Double.parseDouble(str.nextToken());
		}

		String readLine()throws IOException{
			return reader.readLine();
		}

	}

	static class OutputWriter {
		private final PrintWriter writer;

		public OutputWriter(OutputStream outputStream) {
			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
		}

		public OutputWriter(Writer writer) {
			this.writer = new PrintWriter(writer);
		}

		public void print(Object...objects) {
			for (int i = 0; i < objects.length; i++) {
				if (i != 0)
					writer.print(' ');
				writer.print(objects[i]);
			}
		}

	    public void println(Object...objects) {
			print(objects);
			writer.println();
		}

		public void close() {
			writer.close();
		}

	}

}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Saul
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskD {

  public void solve(int testNumber, Scanner in, PrintWriter out) {
    int n = in.nextInt();
    if ( n % 2 == 0 ){
      out.print(0);
    }else{
      long [] toroid = {1, 3, 15, 133, 2025, 37851, 1030367, 36362925};
      long ans = 1;
      final long MOD = (long)1e9+7L;
      for (int i = 1; i <= n; i++) {
        ans = (ans * i) % MOD;
      }
      ans = (toroid[ (n - 1) / 2 ] * ans) % MOD;
      out.print(ans);
    }
  }
}

import java.util.Scanner;
import java.util.TreeMap;

public class D {
    static long mod = 1000000007, f;
    static int n;
    static TreeMap<Integer, Long>[] dp;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();

//      f = 1;
//      for (int i = 2; i <= n; i++)
//          f = (f * i) % mod;

//      dp = new TreeMap[1 << n];
//      for (int i = 0; i < (1 << n); i++)
//          dp[i] = new TreeMap<Integer, Long>();

        int[] res = { 0, 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0,
                890786230, 0, 695720788, 0, 150347555, 0 };
//      long ans = (solve(0, 0, 0) * f) % mod;

        System.out.println(res[n]);
    }

    static int cnt = 0;

    private static long solve(int ai, int mask1, int mask2) {
        if (ai == n) {
            return 1;
        }

        if (dp[mask1].containsKey(mask2)) {
            return dp[mask1].get(mask2);
        }

        ai++;
        long ans = 0;
        for (int bi = 1; bi <= n; bi++)
            if (((mask1 >> (bi - 1)) & 1) == 0) {
                int x = (ai - 1 + bi - 1) % n + 1;

                if (((mask2 >> (x - 1)) & 1) == 0)
                    ans = (ans + solve(ai, mask1 | (1 << (bi - 1)), mask2
                            | (1 << (x - 1))))
                            % mod;
            }

        dp[mask1].put(mask2, ans);
        return ans % mod;
    }
}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import static java.lang.Math.*;
import static java.lang.Integer.*;

@SuppressWarnings("unused")
public class round175D {

    static BufferedReader br = new BufferedReader(new InputStreamReader(
            System.in));
    static StringTokenizer st = new StringTokenizer("");

    static int nextInt() throws Exception {
        return Integer.parseInt(next());
    }

    static String next() throws Exception {
        while (true) {
            if (st.hasMoreTokens()) {
                return st.nextToken();
            }
            String s = br.readLine();
            if (s == null) {
                return null;
            }
            st = new StringTokenizer(s);
        }
    }

    static int n;
    static int mod = (int) (1e9 + 7);
    static int[] sol = new int[] { 1, 3, 15, 133, 2025, 37851, 1030367,
            36362925 };

    public static int factorial(int n) {
        if (n == 0)
            return 1;
        return (int) ((n * 1L * factorial(n - 1)) % mod);
    }

    public static int get(int mask1, int mask2) {
        if (bitCount(mask1) == n && bitCount(mask2) == n)
            return 1;
        int turn = bitCount(mask1);
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (((mask1 >> i) & 1) == 1)
                continue;
            int ansBit = ((i + turn) % n) + 1;
            if (((mask2 >> ansBit) & 1) == 1)
                continue;
            ans += get(mask1 | (1 << i), mask2 | (1 << ansBit));
        }
        return ans;
    }

    public static void main(String[] args) throws Exception {
        n = nextInt();
        if (n % 2 == 0) {
            System.out.println(0);
        } else {
            if (n == 1) {
                System.out.println(1);
            } else {
                long fact = factorial(n);
                System.out.println((fact * (long) sol[n / 2]) % mod);
            }
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author FinnTheHuman
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public static final long mod = 1000000007L;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long[] ans = {0L, 1,
                    0,
                    3,
                    0,
                    15,
                    0,
                    133,
                    0,
                    2025,
                    0,
                    37851,
                    0,
                    1030367,
                    0,
                    36362925,
                    0};
            long n = in.nextLong();
            long x = ans[(int) n];
            for (long i = 1; i <= n; ++i) x = (x * i) % mod;
            out.println(x);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 65536 / 2);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

	static final int mod = (int)1e9 + 7;
	static int n;

	static int f(int i, int usedB, int usedC)
	{
		if(i == n)
			return 1;
		int ret = 0;
		for(int j = 0; j < n; ++j)
			if((usedB & 1 << j) == 0 && (usedC & 1 << (i + j) % n) == 0)
				ret = (ret + f(i + 1, usedB | 1 << j, usedC | 1 << (i + j) % n)) % mod;
		return ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

//		n = sc.nextInt();
//		long[] fac = new long[n + 1];
//		fac[0] = 1;
//		for(int i = 1; i <= n; ++i)
//			fac[i] = i * fac[i - 1] % mod;
//		out.println(fac[n] * f(0, 0, 0) % mod);

		int[] ans = {1,	0, 18, 0, 1800, 0, 670320, 0, 734832000, 0,	890786230, 0, 695720788, 0, 150347555, 0};
		out.println(ans[sc.nextInt() - 1]);
		out.flush();
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException { return Double.parseDouble(next()); }

		public boolean ready() throws IOException {return br.ready();}
	}
}

import java.io.*;

public class CF285D {
	static int M = 1000000007, cnt = 0;
	static void solve(boolean[] bb, int[] cc, int n, int i) {
		if (i == n) {
			cnt = (cnt + 1) % M;
			return;
		}
		for (int k = 0; k <= n - 1 - i; k++) {
			int r = cc[k];
			int j = (r - i + n) % n;
			if (bb[j])
				continue;
			cc[k] = cc[n - 1 - i];
			cc[n - 1 - i] = r;
			bb[j] = true;
			solve(bb, cc, n, i + 1);
			cc[n - 1 - i] = cc[k];
			cc[k] = r;
			bb[j] = false;
		}
	}
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		if (n == 0)
			while (++n <= 15) {
				boolean[] bb = new boolean[n];
				int[] cc = new int[n];
				for (int i = 0; i < n; i++)
					cc[i] = i;
				cnt = 0;
				solve(bb, cc, n, 0);
				for (int i = 1; i <= n; i++)
					cnt = (int) ((long) cnt * i % M);
				System.out.println(cnt);
			}
		else {
			int[] kk = { 0, 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0 };
			System.out.println(kk[n]);
		}
	}
}

/*	/ ﾌﾌ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ム
	/ )\⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀  Y
	(⠀⠀| ( ͡° ͜ʖ ͡°）⠀⌒(⠀ ノ
	(⠀ ﾉ⌒ Y ⌒ヽ-く __／
	| _⠀｡ノ| ノ｡ |/
	(⠀ー '_人`ー ﾉ
	⠀|\ ￣ _人'彡ﾉ
	⠀ )\⠀⠀ ｡⠀⠀ /
	⠀⠀(\⠀ #⠀ /
	⠀/⠀⠀⠀/ὣ====================D-
	/⠀⠀⠀/⠀ \ \⠀⠀\
	( (⠀)⠀⠀⠀⠀ ) ).⠀)
	(⠀⠀)⠀⠀⠀⠀⠀( | /
	|⠀ /⠀⠀⠀⠀⠀⠀ | /
	[_] ⠀⠀⠀⠀⠀[___]                     */
// Main Code at the Bottom
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
	//Fast IO class
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader() {
        	boolean env=System.getProperty("ONLINE_JUDGE") != null;
        	if(!env) {
        		try {
					br=new BufferedReader(new FileReader("src\\input.txt"));
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				}
        	}
        	else br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static long MOD=1000000000+7;
    //Euclidean Algorithm
    static long gcd(long A,long B){
        if(B==0) return A;
        return gcd(B,A%B);
    }
    //Modular Exponentiation
    static long fastExpo(long x,long n){
        if(n==0) return 1;
        if((n&1)==0) return fastExpo((x*x)%MOD,n/2)%MOD;
        return ((x%MOD)*fastExpo((x*x)%MOD,(n-1)/2))%MOD;
    }
    //Prime Number Algorithm
    static boolean isPrime(long n){
        if(n<=1) return false;
        if(n<=3) return true;
        if(n%2==0 || n%3==0) return false;
        for(int i=5;i*i<=n;i+=6) if(n%i==0 || n%(i+2)==0) return false;
        return true;
    }
    //Reverse an array
    static <T> void reverse(T arr[],int l,int r){
    	Collections.reverse(Arrays.asList(arr).subList(l, r));
    }
    //Print array
    static <T> void print1d(T arr[]) {
    	out.println(Arrays.toString(arr));
    }
    static <T> void print2d(T arr[][]) {
    	for(T a[]: arr) out.println(Arrays.toString(a));
    }
    // Pair
    static class pair{
    	long x,y;
    	pair(long a,long b){
    		this.x=a;
    		this.y=b;
    	}
    	public boolean equals(Object obj) {
    		if(obj == null || obj.getClass()!= this.getClass()) return false;
            pair p = (pair) obj;
            return (this.x==p.x && this.y==p.y);
        }
    	public int hashCode() {
            return Objects.hash(x,y);
        }
    }
    static FastReader sc=new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    //Main function(The main code starts from here)
    //Generating permutations
    static ArrayList<int[]> list=new ArrayList<>();
    static void heapPermutation(int a[], int size, int n) {
        if (size == 1) list.add(Arrays.copyOf(a, n));
        for (int i=0; i<size; i++) {
            heapPermutation(a, size-1, n);
            if (size % 2 == 1) {
                int temp = a[0];
                a[0] = a[size-1];
                a[size-1] = temp;
            }
            else {
                int temp = a[i];
                a[i] = a[size-1];
                a[size-1] = temp;
            }
        }
    }
    public static void main (String[] args) throws java.lang.Exception {
    	int test=1;
        while(test-->0) {
        	int n=sc.nextInt(),a[]=new int[n];
        	if(n%2==0) {
        		out.println(0);
        		break;
        	}
        	long map[] = {1L, 3L, 15L, 133L, 2025L, 37851L, 1030367L, 36362925L, 1606008513L};
        	long x=map[n/2];
        	for(int i=1;i<=n;i++) x=(x*i)%MOD;
        	out.println(x);
        }
        out.flush();
        out.close();
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.BufferedInputStream;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		BufferedInputStream in = new BufferedInputStream(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskD {
		int n = 0;

		public void solve(int testNumber, BufferedInputStream _in, PrintWriter out) {

			InputReader in = new InputReader(_in);
			long startTime = System.currentTimeMillis();
			n = in.nextInt();

//		pp = new IPair[n][100];
//		cnt = new int[n];
//		for (int i = 1; i <= n; ++i) {
//			for (int j = 1; j <= n; j++)
//				for (int k = 1; k <= n; k++) {
//					if ((j + k - 2) % n + 1 == i) {
//						pp[i - 1][cnt[i - 1]++] = new IPair(j - 1, k - 1);
//
//					}
//				}
//
//		}
//
//		b1 = new boolean[n];
//		b2 = new boolean[n];
//		rec(0);
//		int [] gt = new int[n + 1];
//		gt[0] = 1;
//		for(int i = 1; i<=n;++i ) gt[i] = Mod.mulMod(gt[i - 1], i );
//		out.println(Mod.mulMod(re, gt[n]));

			int[] ans = new int[17];

			ans[15] = 150347555;
			ans[13] = 695720788;
			ans[11] = 890786230;
			ans[9] = 734832000;
			ans[7] = 670320;
			ans[5] = 1800;
			ans[3] = 18;
			ans[1] = 1;
			out.println(ans[n]);

//		for(int i = 0 ; i < n; ++i) {
//			System.err.println(i + 1);
//			for(int j = 0 ; j < cnt[i]; ++j) {
//				System.err.print(pp[i][j] + ", ");
//			}
//			System.err.println();
//		}
//

			in.close();
			System.err.println("Time: " + (System.currentTimeMillis() - startTime) + " miliseconds");
		}

	}

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public static boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public void close() {

		}

	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class D_Round_175_Div2 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        if (n == 1) {
            out.println(1);
        } else if (n % 2 == 0) {
            out.println(0);
        } else if (n == 15) {
            out.println(150347555);
        } else {
            long count = 0;
            int full = (1 << n) - 1;
            for (int z = 0; z < 1 << n; z++) {
                if (Integer.bitCount(z) == n / 2) {
                    int[] first = new int[n / 2];
                    int[] second = new int[n - (n / 2)];
                    int a = 0;
                    for (int i = 0; i < n; i++) {
                        if (i < n / 2) {
                            first[i] = i;
                        } else {
                            second[a++] = i;
                        }
                    }
                    int[] c = new int[1 << n];
                    do {
                        a = 0;
                        int tmp = 0;
                        for (int i = 0; i < n; i++) {
                            if (((1 << i) & z) != 0) {
                                int v = (i + first[a++]) % n;
                                tmp |= (1 << v);
                            }
                        }
                        c[tmp]++;
                    } while (nextPer(first));
                    do {
                        a = 0;
                        int tmp = 0;
                        for (int i = 0; i < n; i++) {
                            if (((1 << i) & z) == 0) {
                                int v = (i + second[a++]) % n;
                                tmp |= (1 << v);
                            }
                        }
                        count += c[full - tmp];
                    } while (nextPer(second));

                }
            }
            for (int i = 1; i <= n; i++) {
                count *= i;
                count %= MOD;
            }
            out.println(count);
        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return x - o.x;
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static int MOD = 1000000007;

    // After writing solution, quick scan for:
    //   array out of bounds
    //   special cases e.g. n=1?
    //
    // Big numbers arithmetic bugs:
    //   int overflow
    //   sorting, or taking max, after MOD
    long ans = 0;
    long[] fact;
    void solve() throws IOException {
        int n = ri();
        if (n % 2 == 0) pw.println("0");
        else if (n == 9) pw.println("734832000");
        else if (n == 11) pw.println("890786230");
        else if (n == 13) pw.println("695720788");
        else if (n == 15) pw.println("150347555");
        else {
            fact = new long[n+1];
            fact[0] = 1;
            for (int i = 1; i <= n; i++) fact[i] = fact[i-1] * i % MOD;
            boolean[] used1 = new boolean[n];
            boolean[] used2 = new boolean[n];
            helper(n, 0, used1, used2);
            pw.println(ans);
        }
    }

    // used1 is the numbers we chose
    // used2 is the resultant sums
    void helper(int n, int i, boolean[] used1, boolean[] used2) {
        if (i == n) {
            ans = (ans + fact[n]) % MOD;
            return;
        }
        for (int j = 0; j < n; j++) {
            if (used1[j] || used2[(i+j)%n]) continue;
            used1[j] = true;
            used2[(i+j)%n] = true;
            helper(n, i+1, used1, used2);
            used1[j] = false;
            used2[(i+j)%n] = false;
        }
    }

    // Template code below

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException {
        Main m = new Main();
        m.solve();
        m.close();
    }

    void close() throws IOException {
        pw.flush();
        pw.close();
        br.close();
    }

    int ri() throws IOException {
        return Integer.parseInt(br.readLine().trim());
    }

    long rl() throws IOException {
        return Long.parseLong(br.readLine().trim());
    }

    int[] ril(int n) throws IOException {
        int[] nums = new int[n];
        int c = 0;
        for (int i = 0; i < n; i++) {
            int sign = 1;
            c = br.read();
            int x = 0;
            if (c == '-') {
                sign = -1;
                c = br.read();
            }
            while (c >= '0' && c <= '9') {
                x = x * 10 + c - '0';
                c = br.read();
            }
            nums[i] = x * sign;
        }
        while (c != '\n' && c != -1) c = br.read();
        return nums;
    }

    long[] rll(int n) throws IOException {
        long[] nums = new long[n];
        int c = 0;
        for (int i = 0; i < n; i++) {
            int sign = 1;
            c = br.read();
            long x = 0;
            if (c == '-') {
                sign = -1;
                c = br.read();
            }
            while (c >= '0' && c <= '9') {
                x = x * 10 + c - '0';
                c = br.read();
            }
            nums[i] = x * sign;
        }
        while (c != '\n' && c != -1) c = br.read();
        return nums;
    }

    int[] rkil() throws IOException {
        int sign = 1;
        int c = br.read();
        int x = 0;
        if (c == '-') {
            sign = -1;
            c = br.read();
        }
        while (c >= '0' && c <= '9') {
            x = x * 10 + c - '0';
            c = br.read();
        }
        return ril(x);
    }

    long[] rkll() throws IOException {
        int sign = 1;
        int c = br.read();
        int x = 0;
        if (c == '-') {
            sign = -1;
            c = br.read();
        }
        while (c >= '0' && c <= '9') {
            x = x * 10 + c - '0';
            c = br.read();
        }
        return rll(x);
    }

    char[] rs() throws IOException {
        return br.readLine().toCharArray();
    }

    void sort(int[] A) {
        Random r = new Random();
        for (int i = A.length-1; i > 0; i--) {
            int j = r.nextInt(i+1);
            int temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
        Arrays.sort(A);
    }
}

import java.util.Map;
import java.io.IOException;
import java.util.TreeMap;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    final int MOD = (int) (1e9) + 7;
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        Map<Long, Integer> mp = new TreeMap<Long, Integer>();
        int n = in.readInt();
        /*if (n > 9) {
            out.println(0);
            return;
        }*/
        if (n == 11) {
            out.println(890786230);
            return;
        }
        if (n == 13) {
            out.println(695720788);
            return;
        }
        if (n == 15) {
            out.println(150347555);
            return;
        }
        if (n == 14 || n == 16 || n == 12) {
            out.println(0);
            return;
        }

        long[] fact = new long[n + 1];
        fact[0] = 1;
        for (int i = 1; i <= n; ++i) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        long res = go(0, 0, 0, mp, n);
        res *= fact[n];
        res %= MOD;

        out.println(res);
    }

    long marge (long s1, long s2, int n) {
        long res = (s1 << n) | s2;
        return res;
    }

    private int go(int i, int s2, int s3, Map<Long, Integer> mp, int n) {
        long state = marge(s2, s3, n);
        if (mp.containsKey(state)) {
            return mp.get(state);
        }
        if (i == n) {
            //mp.put(state, 1);
            //return mp.get(state);
            return 1;
        }
        int res = 0;
        for (int j = 0; j < n; ++j) {
            if (Bits.IsSet(s2, j)) continue;
            int b = (i + j) % n + 1;
            if (Bits.IsSet(s3, b)) continue;
            int temp = go(i + 1, s2 | (1 << j), s3 | (1 << b), mp, n);
            res = (res + temp) % MOD;
        }
        if (n <= 13) mp.put(state, res);
        return res;
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        // InputMismatchException -> UnknownError
        if (numChars == -1)
            throw new UnknownError();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new UnknownError();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        } else if (c == '+') {
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }

class Bits {

    public static boolean IsSet(int n, int i) {
        return (n & (1 << i)) > 0;
    }

    }

import java.util.Arrays;
import java.util.Scanner;

public class cf_157_D {

//  private static long cur;
//  private static boolean bused[];
//  private static boolean cused[];
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int solution[] ={1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0};
        Scanner cin = new Scanner(System.in);
        int n;
        n = cin.nextInt();
        System.out.println(solution[n-1]);
        /*bused = new boolean[20];
        cused = new boolean[20];
        long res = 1;
        for(int i=1; i<=16; i++){
            if(i%2 == 0){
                System.out.println(0);
                continue;
            }
            res = 1;
            cur = 0;
            for(int j=1; j<=i; j++)
                res = res*j;
            res = res%1000000007;
            Arrays.fill(bused, false);
            Arrays.fill(cused, false);
            dfs(i, 1);
            res = res*cur;
            res = res%1000000007;
            System.out.println(res);
        }*/
    }
/*
    private static void dfs(int n, int step) {
        // TODO Auto-generated method stub
        if(step > n){
            cur++;
            return;
        }
        for(int i=1; i<=n; i++){
            if(bused[i] == false){
                int tmp = (step+i-2)%n + 1;
                if(cused[tmp] == true)
                    continue;
                bused[i] = true;
                cused[tmp] = true;
                dfs(n, step+1);
                bused[i] = false;
                cused[tmp] = false;
            }
        }
        return;
    }*/

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class cf285d {
  static long mod = 7+(int)1e9;
  static int n;
  public static void main(String[] args) {
    FastIO in = new FastIO(), out = in;
    n = in.nextInt();
    long ans = solve(n);
    out.println(ans);
    out.close();
  }
  static long solve(int z) {
    int[] ans = {1,0,18,0,1800,0,670320,0,734832000,0,890786230,0,695720788,0,150347555,0};
    return ans[z-1];
    /*
    System.out.print("{");
    long ans = 0;
    for(int i=1; i<z; i++) {
      n = i;
      System.out.print((ans=go(0, new boolean[n], new boolean[n]))+",");
    }
    n = z;
    System.out.println((ans=go(0,new boolean[n],new boolean[n]))+"}");
    return ans;
    */
  }
  static long go(int pos, boolean[] usedA, boolean[] usedB) {
    if(pos == n) return 1;
    long ans = 0;
    for(int i=0; i<n; i++) {
      if(!usedA[i]) {
        int other = (pos+i)%n;
        if(!usedB[other]) {
          usedA[i] = true;
          usedB[other] = true;
          ans = (ans+go(pos+1,usedA,usedB))%mod;
          usedA[i] = false;
          usedB[other] = false;
        }
      }
    }
    if(pos == 0) {
      for(int i=1; i<=n; i++)
        ans = (ans*i)%mod;
    }
    return ans;
  }
  static class FastIO extends PrintWriter {
    BufferedReader br;
    StringTokenizer st;

    public FastIO() {
      this(System.in,System.out);
    }
    public FastIO(InputStream in, OutputStream out) {
      super(new BufferedWriter(new OutputStreamWriter(out)));
      br = new BufferedReader(new InputStreamReader(in));
      scanLine();
    }
    public void scanLine() {
      try {
        st = new StringTokenizer(br.readLine().trim());
      } catch(Exception e) {
        throw new RuntimeException(e.getMessage());
      }
    }
    public int numTokens() {
      if(!st.hasMoreTokens()) {
        scanLine();
        return numTokens();
      }
      return st.countTokens();
    }
    public String next() {
      if(!st.hasMoreTokens()) {
        scanLine();
        return next();
      }
      return st.nextToken();
    }
    public double nextDouble() {
      return Double.parseDouble(next());
    }
    public long nextLong() {
      return Long.parseLong(next());
    }
    public int nextInt() {
      return Integer.parseInt(next());
    }
  }
}

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
  private static BufferedReader br;
  private static StringTokenizer st;
  private static PrintWriter pw;

  public static void main(String[] args) throws IOException {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    //int qq = 1;
    int qq = Integer.MAX_VALUE;
    //int qq = readInt();
    long[] ret = new long[]{1,3,15,133,2025,37851,1030367,36362925};
    long[] fact = new long[16];
    fact[0] = 1;
    for(int i = 1; i < fact.length; i++) {
      fact[i] = fact[i-1] * i;
    }
    for(int casenum = 1; casenum <= qq; casenum++)  {
      int num = readInt();
      if(num%2==0) {
        pw.println(0);
      }
      else {
        pw.println((ret[num/2] * (fact[num]% 1000000007)) % 1000000007);
      }
    }
    pw.close();
  }

  private static void exitImmediately() {
    pw.close();
    System.exit(0);
  }

  private static long readLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  private static double readDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  private static int readInt() throws IOException {
    return Integer.parseInt(nextToken());
  }

  private static String nextToken() throws IOException  {
    while(st == null || !st.hasMoreTokens())  {
      if(!br.ready()) {
        exitImmediately();
      }
      st = new StringTokenizer(br.readLine().trim());
    }
    return st.nextToken();
  }
}

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

public class Main {

	BufferedReader in;
	StringTokenizer str = null;
	PrintWriter out;

	private String next() throws Exception{
		if (str == null || !str.hasMoreElements())
			str = new StringTokenizer(in.readLine());
		return str.nextToken();
	}

	private int nextInt() throws Exception{
		return Integer.parseInt(next());
	}

	private long nextLong() throws Exception{
		return Long.parseLong(next());
	}

	private double nextDouble() throws Exception{
		return Double.parseDouble(next());
	}

	private final long MOD = 1000000007;

	public void run() throws Exception{
		in =  new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		int n = nextInt();
		if (n % 2 == 0){
			out.println(0);
			out.close();
			return;
		}

		long p = 1;
		for(int i=1;i<=n;i++){
			p*=i;
			p%=MOD;
		}

		long ans[] = new long[]{0, 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 37851, 0, 1030367, 0, 36362925};
		p*=ans[n];
		out.println(p%MOD);
		out.close();
	}

	public static void main(String[] args) throws Exception{
		new Main().run();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class D {
	BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

    int[][] result;
    int MODULAR = 1000000007;
    int N;
	public void solve() throws IOException {
		N = nextInt();

		if( N % 2 == 0 ){
			out.println(0); return;
		}
		else if( N == 15 ){
			out.println(150347555); return;
		}

		result =  new int[N+1][N+1];
		for(int i = 1; i <= N; i++){
			for(int j = 1; j <= N; j++){
				result[i][j] = (i-1+j-1) % N + 1;
			}
		}

		boolean[] usedB = new boolean[N+1];
		boolean[] usedC = new boolean[N+1];
		long ans = dfs(1, usedB, usedC);

		long p = 1;
		for(int i = 1; i <= N; i++){
			p = (p * i) % MODULAR;
		}
		ans = (ans * p) % MODULAR;
		out.println( ans);
	}

	public long dfs(int pos, boolean[] usedB, boolean[] usedC){

		if( pos > N ) {
//			out.println("ans +1");
			return 1;
		}

		long ans = 0;
		for(int i = 1; i <= N; i++){
			if( usedB[i] ){
				continue;
			}
			usedB[i] = true;

			int c = result[pos][i];
			if( !usedC[c] ){
//				out.println("using: " + c);
				usedC[c] = true;
				ans += dfs( pos+1, usedB, usedC );
				usedC[c] = false;
			}

			usedB[i] = false;
		}
		return ans;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new D().run();
	}

	public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            reader.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}

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

public class D implements Runnable {

	long[] ans = { 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 37851, 0, 1030367, 0, 36362925, 0 };

	final long MOD = 1000000000 + 7;

	private void solve() throws IOException {
		int n = nextInt();
		long res = ans[n - 1];
		for (long i = 2; i <= n; i++) {
			res *= i;
			res %= MOD;
		}
		print(res);
	}

	public static void main(String[] args) {
		new D().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			writer = new PrintWriter(System.out);
			solve();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(261);
		}
	}

	void halt() {
		writer.close();
		System.exit(0);
	}

	void print(Object... objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	void println(Object... objects) {
		print(objects);
		writer.println();
	}

	String nextLine() throws IOException {
		return reader.readLine();
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(nextLine());
		return tokenizer.nextToken();
	}

	int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    int mod=1000000007;
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int n=in.nextInt();
        int val[]=new int[]{1, 3, 15, 133, 2025, 37851, 1030367, 36362925};
        if(n%2==0) out.println(0);
        else out.println((fact(n)*val[(n-1)/2])%mod);
    }
    public long fact(int a){
        if(a==1)
            return 1;
        return (a*fact(a-1))%mod;
    }
}

import java.util.*;
import java.io.*;
public class a {
  static long mod = 1000000007;
public static void main(String[] args) throws IOException
{
  input.init(System.in);
  PrintWriter out = new PrintWriter(new PrintStream(System.out));
  //input.init(new FileInputStream(new File("input.txt")));
  //PrintWriter out = new PrintWriter(new File("output.txt"));
  int[] ans = new int[]{
      1,
      0,
      18,
      0,
      1800,
      0,
      670320,
      0,
      734832000,
      0,
      890786230,
      0,
      695720788,
      0,
      150347555,
      0
  };
  int n = input.nextInt();
  out.println(ans[n-1]);
//  long[] data = new long[17];
//  for(int i = 1; i<=n; i++)
//  {
//    count = 0;
//    perm(new boolean[i], new boolean[i], i, 0);
//    for(int j = 1; j<=i; j++)
//      count = (count*j)%mod;
//    System.out.println(count);
//  }
  //out.println(data[n]);

  out.close();
}
static long count;
static void perm(boolean[] data, boolean[] used, int n, int at)
{
  if(at==n) count++;
  for(int i = 0; i<n; i++)
  {
    int res = (i+at)%n;
    if(!used[i] && !data[res])
    {
      data[res] = true;
      used[i] = true;
      perm(data, used, n, at+1);
      data[res] = false;
      used[i] = false;
    }
  }
}
static long gcd(long a, long b)
{
  if(b==0) return a;
  return gcd(b, a%b);
}
static long pow(long a, long p)
{
  if(p<=0) return 1;
  if((p&1) == 0)
  {
    long sqrt = pow(a, p/2);
    return (sqrt*sqrt)%mod;
  }
  else
    return (a*pow(a,p-1))%mod;
}
static class input {
  static BufferedReader reader;
  static StringTokenizer tokenizer;

  /** call this method to initialize reader for InputStream */
  static void init(InputStream input) {
      reader = new BufferedReader(
                   new InputStreamReader(input) );
      tokenizer = new StringTokenizer("");
  }

  /** get next word */
  static String next() throws IOException {
      while ( ! tokenizer.hasMoreTokens() ) {
          //TODO add check for eof if necessary
          tokenizer = new StringTokenizer(
                 reader.readLine() );
      }
      return tokenizer.nextToken();
  }

  static int nextInt() throws IOException {
      return Integer.parseInt( next() );
  }
  static long nextLong() throws IOException {
    return Long.parseLong( next() );
}

  static double nextDouble() throws IOException {
      return Double.parseDouble( next() );
  }
  static String nextLine() throws IOException {
    return reader.readLine();
  }
}
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CodeD
{
	static int n;

	@SuppressWarnings("unchecked")
	static HashMap <Integer, Long> [] dp = new HashMap[1 << 16];
	static long MOD = 1000000007;

	static HashMap <Integer, Long> dp(int mascara)
	{
		if(dp[mascara] != null)
			return dp[mascara];
		int indiceActual = Integer.bitCount(mascara);
		if(indiceActual == n)
		{
			HashMap <Integer, Long> ans = new HashMap <Integer, Long> ();
			ans.put(0, 1L);
			return dp[mascara] = ans;
		}
		else
		{
			HashMap <Integer, Long> answers = new HashMap <Integer, Long> ();
			for(int i = 0; i < n; i++)
			{
				if((mascara & (1 << i)) == 0)
				{
					int indiceC = (i + indiceActual) % n;
					int mascaraSig = 1 << indiceC;
					for(Map.Entry<Integer, Long> e : dp(mascara ^ (1 << i)).entrySet())
					{
						int v = e.getKey();
						if((v & mascaraSig) == 0)
						{
							int n = v ^ mascaraSig;
							if(!answers.containsKey(n))
								answers.put(n, 0L);
							answers.put(n, (answers.get(n) + e.getValue()) % MOD);
						}
					}
				}
			}
			return dp[mascara] = answers;
		}
	}

	static int[] ans = {0, 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0};
	@SuppressWarnings("unchecked")
	public static void main(String[] args)
	{
//		long[] factorial = new long[17];
//		factorial[0] = 1L;
//		for(int i = 1; i < 17; i++)
//			factorial[i] = (factorial[i - 1] * i) % MOD;
//		for(int i = 0; i <= 16; i++)
//		{
//			if((i & 1) == 0)
//				System.out.print("0, ");
//			else
//			{
//				n = i;
//				dp = new HashMap[1 << n];
//				long ans = 0;
//				for(long v : dp(0).values())
//				{
//					ans += v;
//					ans %= MOD;
//				}
//				ans *= factorial[n];
//				ans %= MOD;
//				System.out.print(ans + ", ");
//			}
//		}
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		System.out.println(ans[n]);
	}
}

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

public class Permutation {
	public static void main(String[] args) throws IOException {
		PrintWriter pw  = new PrintWriter(System.out);
		BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(rd.readLine());
		n = Integer.parseInt(st.nextToken());
		if(n%2==0){
			System.out.println(0);
			return;
		}
		int[] res = new int[]{1, 18, 1800, 670320, 734832000, 890786230, 695720788, 150347555};
		System.out.println(res[(n-1)/2]);
//		for(int i=0; i<15; i++) for(int j=0; j<(1<<15);j++) m[i][j] = new HashMap<Short, Integer>();
//		long ans = find(1, (1<<10), (short)(1<<10));
//		ans = (ans*15)%P;
//		for(int i=1; i<=n; i++) ans = (ans*i)%P;
//		System.out.println(ans);
	}

	static int find(int pos, int mask1, short mask2){
	//	System.out.println(pos+" "+mask1+" "+mask2);
		if(pos==n) return 1;
		if(m[pos][mask1].containsKey(mask2)) return m[pos][mask1].get(mask2);
	//	if(d[pos][mask1][mask2]!=-1) return d[pos][mask1][mask2];
		long ans = 0;
		for(int x=0; x<n; x++){
			if((mask1&(1<<x))!=0) continue;
			int next = (x+pos)%n;
			if((mask2&(1<<next))!=0) continue;
			ans += find(pos+1, (mask1^(1<<x)), (short)(mask2^(1<<next)));
		}
		ans %= P;
		m[pos][mask1].put(mask2, (int) ans);
	//	d[pos][mask1][mask2] = (int) ans;
		return (int) ans;
	}

	static HashMap<Short, Integer>[][] m = new HashMap[15][1<<15];

	static int n;

	static final int P = 1000000007;

}
// 343356506
// 343356506
// 343356506

import java.util.*;
import java.math.*;
import java.io.*;

public class Main
	{
	public static void main(String args[]) throws IOException
		{
		int A[]=new int[]{0,1,0,3,0,15,0,133,0,2025,0,37851,0,1030367,0,36362925,0};
		InputReader in=new InputReader(System.in);
		int N=in.readInt();
		long mod=1000000007;
		System.out.println(((fact(N)%mod)*A[N])%mod);
		}

	public static long fact(int n)
		{
		long ans=1;
		for(int i=1;i<=n;i++)
			ans*=i;
		return ans;
		}
	}

class InputReader
	{
	private InputStream stream;
	private byte[] buf=new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream)
		{
		this.stream=stream;
		}

	public int read()
		{
		if(numChars==-1)
			throw new InputMismatchException();
		if(curChar>=numChars)
			{
			curChar=0;
			try
				{
				numChars=stream.read(buf);
				} catch (IOException e)
				{
				throw new InputMismatchException();
				}
			if(numChars<=0)
				return -1;
			}
		return buf[curChar++];
		}

	public int readInt()
		{
		int c=read();
		while (isSpaceChar(c))
			c=read();
		int sgn=1;
		if(c=='-')
			{
			sgn=-1;
			c=read();
			}
		int res=0;
		do
			{
			if(c<'0'||c>'9')
				throw new InputMismatchException();
			res*=10;
			res+=c-'0';
			c=read();
			} while (!isSpaceChar(c));
		return res*sgn;
		}

	public boolean isSpaceChar(int c)
		{
		if(filter!=null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
		}

	public static boolean isWhitespace(int c)
		{
		return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
		}

	public char readCharacter()
		{
		int c=read();
		while (isSpaceChar(c))
			c=read();
		return (char) c;
		}

	public interface SpaceCharFilter
		{
		public boolean isSpaceChar(int ch);
		}
	}

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

public class Main
{
	public static void main(String[] arg)
	{
		new Main();
	}
	Main()
	{
		InputReader cin=new InputReader(System.in);
		int n=cin.readInt();
		long[] lst=new long[]{1, 3, 15, 133, 2025, 37851, 1030367, 36362925};//, 1606008513, 87656896891, 5778121715415, 452794797220965, 41609568918940625};
		if (n%2==0) System.out.println(0);
		else
		{
			long ans=lst[n/2];
			for (int i=1;i<=n;i++) ans=ans*i%1000000007;
			System.out.println(ans);
		}
	}
}

class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long readLong() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main (String []args) throws IOException{
		Scanner in = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int n = in.nextInt();
		BigInteger b[] = new BigInteger[30];
		b[0] = BigInteger.ONE;
		for(int i=1; i<=n; i++)
			b[i] = b[i-1].multiply(BigInteger.valueOf(i));
		long a[] = { 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 37851, 0, 1030367, 0, 36362925, 0};
        pw.print(b[n].multiply(BigInteger.valueOf(a[n-1])).mod(BigInteger.valueOf(1000000007)));
		pw.close();
	}
}

import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class D {

	final static boolean autoflush = false;

	final static int MOD = (int) 1e9 + 7;
	final static double eps = 1e-9;
	final static int INF = (int) 1e9;

	long [] res = { 0, 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0 };
	public D () {
		exit(res[sc.nextInt()]);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static int [] rep(int N) { return rep(0, N); }
	static int [] rep(int S, int T) { int [] res = new int [max(T-S, 0)]; for (int i = S; i < T; ++i) res[i-S] = i; return res; }
	static int [] req(int S, int T) { return rep(S, T+1); }

	////////////////////////////////////////////////////////////////////////////////////

	/* Dear hacker, don't bother reading below this line, unless you want to help me debug my I/O routines :-) */

	final static MyScanner sc = new MyScanner();

	static class MyScanner {
		public String next() {
			newLine();
			return line[index++];
		}

		public char nextChar() {
			return next().charAt(0);
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public String nextLine() {
			line = null;
			return readLine();
		}

		public String [] nextStrings() {
			line = null;
			return readLine().split(" ");
		}

		public char [] nextChars() {
			return next ().toCharArray ();
		}

		public Integer [] nextInts() {
			String [] L = nextStrings();
			Integer [] res = new Integer [L.length];
			for (int i : rep(L.length))
				res[i] = Integer.parseInt(L[i]);
			return res;
		}

		public Long [] nextLongs() {
			String [] L = nextStrings();
			Long [] res = new Long [L.length];
			for (int i : rep(L.length))
				res[i] = Long.parseLong(L[i]);
			return res;
		}

		public Double [] nextDoubles() {
			String [] L = nextStrings();
			Double [] res = new Double [L.length];
			for (int i : rep(L.length))
				res[i] = Double.parseDouble(L[i]);
			return res;
		}

		public String [] next (int N) {
			String [] res = new String [N];
			for (int i : rep(N))
				res[i] = sc.next();
			return res;
		}

		public Integer [] nextInt (int N) {
			Integer [] res = new Integer [N];
			for (int i : rep(N))
				res[i] = sc.nextInt();
			return res;
		}

		public Long [] nextLong (int N) {
			Long [] res = new Long [N];
			for (int i : rep(N))
				res[i] = sc.nextLong();
			return res;
		}

		public Double [] nextDouble (int N) {
			Double [] res = new Double [N];
			for (int i : rep(N))
				res[i] = sc.nextDouble();
			return res;
		}

		public String [][] nextStrings (int N) {
			String [][] res = new String [N][];
			for (int i : rep(N))
				res[i] = sc.nextStrings();
			return res;
		}

		public Integer [][] nextInts (int N) {
			Integer [][] res = new Integer [N][];
			for (int i : rep(N))
				res[i] = sc.nextInts();
			return res;
		}

		public Long [][] nextLongs (int N) {
			Long [][] res = new Long [N][];
			for (int i : rep(N))
				res[i] = sc.nextLongs();
			return res;
		}

		public Double [][] nextDoubles (int N) {
			Double [][] res = new Double [N][];
			for (int i : rep(N))
				res[i] = sc.nextDoubles();
			return res;
		}

		//////////////////////////////////////////////

		private boolean eol() {
			return index == line.length;
		}

		private String readLine() {
			try {
				return r.readLine();
			} catch (Exception e) {
				throw new Error (e);
			}
		}
		private final java.io.BufferedReader r;

		MyScanner () {
			this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in)));
		}

		MyScanner (java.io.BufferedReader r) {
			try {
				this.r = r;
				while (!r.ready())
					Thread.sleep(1);
				start();
			} catch (Exception e) {
				throw new Error(e);
			}
		}

		private String [] line;
		private int index;

		private void newLine() {
			if (line == null || eol()) {
				line = readLine().split(" ");
				index = 0;
			}
		}
	}

	static void print (Object o, Object... a) {
		printDelim(" ", o, a);
	}

	static void cprint (Object o, Object... a) {
		printDelim("", o, a);
	}

	static void printDelim (String delim, Object o, Object... a) {
		pw.println(build(delim, o, a));
	}

	static void exit (Object o, Object... a) {
		print(o, a);
		exit();
	}

	static void exit() {
		pw.close();
		System.out.flush();
		System.err.println("------------------");
		System.err.println("Time: " + ((millis() - t) / 1000.0));
		System.exit(0);
	}

	static void NO() {
		throw new Error("NO!");
	}

	////////////////////////////////////////////////////////////////////////////////////

	static String build (String delim, Object o, Object... a) {
		StringBuilder b = new StringBuilder();
		append(b, o, delim);
		for (Object p : a)
			append(b, p, delim);
		return b.toString().trim();
	}

	static void append(StringBuilder b, Object o, String delim) {
		if (o.getClass().isArray()) {
			int L = java.lang.reflect.Array.getLength(o);
			for (int i : rep(L))
				append(b, java.lang.reflect.Array.get(o, i), delim);
		} else if (o instanceof Iterable<?>)
			for (Object p : (Iterable<?>)o)
				append(b, p, delim);
		else
			b.append(delim).append(o);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static void statics() {
		abs(0);
		valueOf(0);
		asList(new Object [0]);
		reverseOrder();
	}

	public static void main (String[] args) {
		new D();
		exit();
	}

	static void start() {
		t = millis();
	}

	static java.io.PrintWriter pw = new java.io.PrintWriter(System.out, autoflush);

	static long t;

	static long millis() {
		return System.currentTimeMillis();
	}
}

// @author Sanzhar
import java.io.*;
import java.util.*;
import java.awt.Point;

public class Template {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st;

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(in.readLine());
            } catch (Exception e) {
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    public void run() throws Exception {
        //in = new BufferedReader(new FileReader("input.txt"));
        //out = new PrintWriter(new FileWriter("output.txt"));
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.flush();
        out.close();
        in.close();
    }

    public void solve() throws Exception {
        int n = nextInt();
        if (n % 2 == 0) {
            out.println(0);
            return;
        }
        long d[] = {0, 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 37851, 0, 1030367, 0, 36362925};
        long mod = 1000000007;
        long ans = 1;
        for (long i = 1; i <= n; i++) {
            ans *= i;
            ans %= mod;
        }
        ans = (ans * d[n]) % mod;
        out.println(ans);
    }

    public static void main(String[] args) throws Exception {
        new Template().run();
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String args[]){
		Scanner input = new Scanner(System.in);
		sumperm(input.nextInt());
		input.close();
	}

	public static long factmod(int n, int p){
		long res = 1;
		for(int i=1; i<=n; i++){
			res = (res % p)*(i % p);
		}
		return (res % p);
	}

	public static void sumperm(int n){
		Integer[] results = new Integer[]{1,0,18,0,1800,0,670320,0,734832000,0,890786230,0,695720788,0,150347555,0};
		System.out.println(results[n-1]);
	}

	//implementation from betlista, codeforces
	public static boolean next_permutation(int[] p) {
		for (int a = p.length - 2; a >= 0; --a)
			if (p[a] < p[a + 1])
				for (int b = p.length - 1;; --b)
					if (p[b] > p[a]) {
						int t = p[a];
						p[a] = p[b];
						p[b] = t;
						for (++a, b = p.length - 1; a < b; ++a, --b) {
							t = p[a];
							p[a] = p[b];
							p[b] = t;
						}
						return true;
					}
		return false;
	}

	public static int[] permadd(int[] a, int[] b){
		int[] c = new int[a.length];
		for(int i=0; i<a.length; i++){
			c[i] = ((a[i] - 1 + b[i] - 1) % a.length) + 1;
		}
		return c;
	}

	public static boolean isperm(int[] a){
		Arrays.sort(a);
		for(int i=0; i<a.length; i++){
			if(i+1 != a[i]){
				return false;
			}
		}
		return true;
	}
}

import java.io.*;
import java.util.*;
public class z2 {
	public static int[] b=new int[20];
	public static long fact(long a) {if (a<=1) return 1; else return (a*fact(a-1))%1000000007;}
	public static long peres(int a,int n)
	{
		long ch=0;
		boolean flag;
		if (a>n) return 1; else
		{
			for (int i=1;i<=n;i++)
			{   flag=false;
				for (int j=1;j<a;j++)
				{
					if ((b[j]==i)||((i+a-b[j]-j)%n==0)) {flag=true;break;}
				}
				if (flag) continue;
				b[a]=i;
				ch=(ch+peres(a+1,n))%1000000007;
			}
		}
		return ch;
	}
	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		int n=in.nextInt();
		if (n%2==0) System.out.println(0); else
		if (n==15) System.out.println(150347555); else
		{
		b[1]=1;
		System.out.println((n*fact(n)*peres(2,n))%1000000007L);}
	}
}

import java.io.*;
import java.util.*;
public class z2 {
	public static int n;
	public static int[] b=new int[20];
	public static int[] c=new int[20];
	public static long fact(long a) {if (a<=1) return 1; else return (a*fact(a-1))%1000000007;}
	public static long peres(int a)
	{
		long ch=0;
		if (a>n) return 1; else
		{
			for (int i=2;i<=n;i++)
			{
				if ((b[i]==1)||(c[(i+a-2)%n+1]==1)) continue;
				b[i]=1;
				c[(i+a-2)%n+1]=1;
				ch+=peres(a+1);
				b[i]=0;
				c[(i+a-2)%n+1]=0;
			}
		}
		return ch;
	}
	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		n=in.nextInt();
		if (n%2==0) System.out.println(0); else
		if (n==15) System.out.println(150347555); else
		{
		for (int i=0;i<20;i++) {b[i]=0;c[i]=0;};
		b[1]=1;c[1]=1;
		System.out.println((n*fact(n)*peres(2))%1000000007L);}
	}
}

import java.io.*;
import java.util.*;
public class D {

	long MOD = 1000000007;

	int n;
	long count = 0;

	long[] mul = new long[] {3, 15, 133, 2025, 37851, 1030367, 36362925};

    public void solve() throws IOException {
        n = nextInt();
        //go(0, 0, 0);
        //writer.println(count);
        if (n == 1) writer.println(1);
        else
        if (n % 2 == 0) writer.println(0);
        else {
        	long ans = mul[(n - 3) / 2];
        	for (int i = 1; i <= n; i++) ans = (ans * i) % MOD;
        	writer.println(ans);
        }
    }

    boolean inBit(int x, int mask) {
    	return ((mask >> x) & 1) == 1;
    }

    void go(int row, int maskCol, int maskVal) {
    	if (row == n) count++;
    	for (int col = 0; col < n; col++)
    		if (!inBit(col, maskCol) && !inBit((row + col) % n, maskVal))
    			go(row + 1, maskCol ^ (1 << col), maskVal ^ (1 << ((row + col) % n)));
    }

    public static void main(String[] args) throws FileNotFoundException {
        new D().run();
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            long tbegin = System.currentTimeMillis();
            reader = new BufferedReader(new InputStreamReader(System.in));
            //reader = new BufferedReader(new InputStreamReader(new FileInputStream("art.in")));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            //writer = new PrintWriter(new FileOutputStream("art.out"));
            solve();
            //reader.close();
            //System.out.println(System.currentTimeMillis() - tbegin + "ms");
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}

import	java.util.*;
public	class	Main{
	public	static	void	main(String[]args){
		int[]Q={1,18,1800,670320,734832000,890786230,695720788,150347555};
		Scanner	cin=new	Scanner(System.in);
		int	n=cin.nextInt();
		System.out.print(0!=(1&n)?Q[n>>1]:0);
	}
}

import java.util.*;

public class Main {
  static int MOD = 1000000007;

  public static void main(String[] strings) {
//    for (int n = 1; n <= 16; ++n) {
//      int res = solve(n, 0, 0, 0);
//      System.err.println(cache.size());
//      for (int i = 1; i <= n; ++i) {
//      }
//      System.out.println("p[" + (new Integer(n)).toString() + "] = " + (new Long(res)).toString() + ";");
//    }
    int[] p = new int[17];
    p[1] = 1;
    p[2] = 0;
    p[3] = 3;
    p[4] = 0;
    p[5] = 15;
    p[6] = 0;
    p[7] = 133;
    p[8] = 0;
    p[9] = 2025;
    p[10] = 0;
    p[11] = 37851;
    p[12] = 0;
    p[13] = 1030367;
    p[14] = 0;
    p[15] = 36362925;
    p[16] = 0;
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int res = p[n];
    for (int i = 1; i <= n; ++i) {
      res = (int)(((long)res * i) % MOD);
    }
    System.out.println(res);
  }

//  private static int solve(int n, int at, int used, int sums) {
//    if (n % 2 == 0) {
//      return 0;
//    }
//    if (at == n) {
//      return 1;
//    }
//    int res = 0;
//    for (int x = 0; x < n; ++x) {
//      int y = (x + at) % n;
//      if ((used & (1 << x)) == 0 && (sums & (1 << y)) == 0) {
//        res = (res + solve(n, at + 1, used | (1 << x), sums | (1 << y))) % MOD;
//      }
//    }
//    return res;
//  }
}

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

public class Solution {
    public static void main (String args[]) throws Exception {
        boolean online = "true".equals(System.getProperty("ONLINE_JUDGE"));
        if (online) {
            in = new InputReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        else {
            in = new InputReader(new FileReader("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        }

        new Solution().run();

        out.close();
    }

    int n;
    /*int[][] pos;
    boolean[] used, usedpos;*/

    /*int rec (int[] p, int sz) {
        if (sz == n) return 1;
        int ans = 0;
        for (int i = 1; i <= n; ++i) {
            if (used[i] || usedpos[pos[i][sz]]) continue;
            usedpos[pos[i][sz]] = true;
            p[sz] = i;
            used[i] = true;
            ans += rec(p, sz+1);
            used[i] = false;
            usedpos[pos[i][sz]] = false;
        }
        return ans;
    }*/

    void run () {
        n = in.nextInt();
        if (n % 2 == 0) {
            out.println(0);
            return;
        }
        long ans = 1;
        for (int i = 1; i <= n; ++i)
            ans = (ans * i) % P;
        long[] p = {1, 3, 15, 133, 2025, 37851, 1030367, 36362925};
        ans = (ans * p[n/2]) % P;
        out.println(ans);
    }

    private static final int P = 1000000007;

    private static InputReader in;
    private static PrintWriter out;
}

class InputReader {
    public InputReader(Reader in) {
        buff = new BufferedReader(in);
    }

    public String next () {
        while (str == null || !str.hasMoreTokens())
            try {
                str = new StringTokenizer(buff.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        return str.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(this.next());
    }

    private static BufferedReader buff;
    private static StringTokenizer str;
}

import java.util.*;
public class Main {
    /*
    static int N;
    static final int mod = 1000000007;
    static long fact(int n) {
        long ret = 1;
        for (int i=2; i<=n; i++)
            ret = (ret*i)%mod;
        return ret;
    }
    static HashMap<Integer,Integer>[] memo;
    static int foo(int n, int usedPerm, int usedSum) {
        if (n==N)
            return 1;
        Integer m = memo[usedPerm].get(usedSum);
        if (m != null)
            return m;
        int ret = 0;
        for (int i=0; i<N; i++) {
            if (((usedPerm>>i)&1)==1)
                continue;
            int sum = (n + i)%N;
            if (((usedSum>>sum)&1)==1)
                continue;
            ret = (int)(((long)ret + foo(n+1,usedPerm|(1<<i),usedSum|(1<<sum)))%mod);
        }
        memo[usedPerm].put(usedSum,ret);
        return ret;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        N = in.nextInt();
        memo = new HashMap[1<<N];
        for (int i=0; i<memo.length; i++)
            memo[i] = new HashMap<Integer,Integer>();
        System.out.println((foo(0,0,0)*fact(N))%mod);
    }
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println(new int[]{1,0,18,0,1800,0,670320,0,734832000,0,890786230,0,695720788,0,150347555,0}[in.nextInt()-1]);
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class PermutationSumRedo {
	static int M = 1000000007;
	static int n;
	static long res = 0;
	public static void main(String[] args){
		FastScanner sc = new FastScanner();
		n = sc.nextInt();
		if(n%2==0){
			System.out.println(0);
			return;
		}

		if(n==15){
			System.out.println(150347555);
		}else if(n==13){
			System.out.println(695720788);
		}else{
			long fac = fac(n);
			count(new HashSet<Integer>(), new HashSet<Integer>(), 1);
			System.out.println((fac * res) % M);
		}

	}

	//if a is fixed to 1,2,3...,n
	//how many possible b such that c is a valid permutation?
	//nextFill starts from 1...n, to indicate which kth element of b to fill next
	public static void count(Set<Integer> c, Set<Integer> b, int nextFill){
		if(nextFill == n+1){
			res++;
			res %= M;
		}

		for(int i=1;i<=n;i++){
			int ci = (nextFill + i -2) % n;
			if(!b.contains(i) && !c.contains(ci)){
				//add an extra brute force for b
				b.add(i);
				c.add(ci);

				count(c,b,nextFill+1);

				b.remove(i);
				c.remove(ci);
			}
		}
	}

	public static long fac(long n){
		long i =1;
		for(int j=1;j<=n;j++){
			i = (i*j)%M;
		}

		return i;
	}

	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.StringTokenizer;

public class Round175_E {

    int[][] arr;
    int N;

    int maskY, maskZ;
    long mod = 1000000007;
    long fact[];

    Hashtable<String, Long> hash = new Hashtable<String, Long>();

    public long go(int row) {

        if (row == N)
            return fact[N];
        // if (hash.contains(row + " " + maskY + " " + maskZ))
        // return hash.get(row + " " + maskY + " " + maskZ);
        long ans = 0;
        for (int j = 0; j < N; j++) {
            if ((maskY & (1 << j)) == 0 && (maskZ & (1 << arr[row][j])) == 0) {
                int prevY = maskY;
                int prevZ = maskZ;
                maskY |= (1 << j);
                maskZ |= (1 << arr[row][j]);
                ans += go(row + 1) % mod;
                ans = ans % mod;
                maskY = prevY;
                maskZ = prevZ;

            }
        }
        // hash.put(row + " " + maskY + " " + maskZ, ans);
        return ans;
    }

    public void solve() throws Exception {

        InputReader in = new InputReader();

        // for (int zz = 1; zz <= 16; zz++) {
        // N = zz;
        // arr = new int[N][N];
        // for (int i = 0; i < N; i++)
        // for (int j = 0; j < N; j++) {
        // arr[i][j] = ((i + 1 + j + 1 - 2) % N);
        // }
        //
        // maskY = 0;
        // maskZ = 0;
        // fact = new long[N + 2];
        // fact[0] = 1;
        // fact[1] = 1;
        // for (int i = 2; i < N + 2; i++) {
        // fact[i] = ((fact[i - 1] % mod) * (long) i) % mod;
        // }
        // // for (int i = 0; i < N; i++)
        // // for (int j = 0; j < N; j++)
        // // System.out.println(arr[i][j]);
        //
        // long ans = go(0);
        // System.out.println(ans);
        // }
        long ans[] = new long[] { 0, 1, 0, 18, 0, 1800, 0, 670320, 0,
                734832000, 0, 890786230, 0, 695720788, 0, 150347555, 0 };
        System.out.println(ans[in.nextInt()]);

    }

    public static void main(String[] args) throws Exception {
        new Round175_E().solve();
    }

    static class InputReader {
        BufferedReader in;
        StringTokenizer st;

        public InputReader() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            st = new StringTokenizer(in.readLine());

        }

        public String next() throws IOException {

            while (!st.hasMoreElements())
                st = new StringTokenizer(in.readLine());
            return st.nextToken();
        }

        public int nextInt() throws NumberFormatException, IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws NumberFormatException, IOException {
            return Long.parseLong(next());
        }
    }

}

import java.util.*; //Scanner;
import java.io.PrintWriter; //PrintWriter

public class R175_Div2_D //Name: Permutation Sum
{
	public static void main(String[] args) {
		Scanner      in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		solve(in, out);
		out.close();
		in.close();
	}

	public static void solve(Scanner in, PrintWriter out)
	{
		int n = in.nextInt();

        long mod = 1_000_000_007;
        //An even input n will have an output of 0
        int[] a = { 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 37851, 0, 1030367, 0, 36362925, 0 };

        long f = a[n-1];
        for (int i = 1; i <= n; i++)
        {
            f *= i;
            f %= mod;
        }

		out.println(f);
	}
}

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";
	}
}

import java.util.Scanner;

public class D {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] mas = {0,1,0,18,0,1800,0,670320,0,734832000,0,890786230,0,695720788,0,150347555};
		int n = sc.nextInt();
		if (n%2 == 0) {
			System.out.println(0);
		}else{
			System.out.println(mas[n]);
		}
	}
}

import java.util.Scanner;

public class D {
    static int n;
    static int mod = (int) 1e9 + 7;

    public static long rec(int index, int mask1, int mask2) {
        if (index == n)
            return 1;
        long ans = 0;
        for (int i = 0; i < n; i++)
            if ((mask1 & (1 << i)) == 0
                    && (mask2 & (1 << ((index - i + n) % n))) == 0)
                ans = (ans + rec(index + 1, mask1 | (1 << i), mask2
                        | (1 << ((index - i + n) % n))))
                        % mod;
        return ((n - index) * ans) % mod;
    }

    public static void main(String[] args) {
        int[] A = { 1, 0, 18, 0, 1800, 0, 670320, 0, 734832000, 0, 890786230,
                0, 695720788, 0, 150347555, 0 };
        Scanner in = new Scanner(System.in);
        System.out.println(A[in.nextInt() - 1]);
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Solver {

	public static void main(String[] Args) throws NumberFormatException,
			IOException {
		new Solver().Run();
	}

	PrintWriter pw;
	StringTokenizer Stok;
	BufferedReader br;

	public String nextToken() throws IOException {
		while (Stok == null || !Stok.hasMoreTokens()) {
			Stok = new StringTokenizer(br.readLine());
		}
		return Stok.nextToken();
	}

	public int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextToken());
	}

	public long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(nextToken());
	}

	final long mod=1000000007;
	int size;
	long result=0;
	int[] diags, usedElems;
	int[] resMas=new int[17];

	void countRez(int dep){
		if (dep>=size){
			result++;
			return;
		}

		int zn;
		for (int j=0; j<size; j++){
			if (usedElems[j]==0){
				zn=dep-j;
				if (zn<0)
					zn+=size;
				if (diags[zn]==0){
					diags[zn]=1;
					usedElems[j]=1;
					countRez(dep+1);
					diags[zn]=0;
					usedElems[j]=0;
				}
			}
		}
	}

	void countFinal(){
		/*for (int i=2; i<=size; i++){
			result=(result*i)%mod;
		}*/
		resMas[15]=150347555;
		resMas[13]=695720788;
		resMas[11]=890786230;
		resMas[9]=734832000;
		resMas[7]=670320;
		resMas[5]=1800;
		resMas[3]=18;
		resMas[1]=1;
	}

	public void Run() throws NumberFormatException, IOException {
		//br = new BufferedReader(new FileReader("input.txt")); pw = new PrintWriter("output.txt");
		br=new BufferedReader(new InputStreamReader(System.in));  pw=new PrintWriter(new OutputStreamWriter(System.out));
		size=nextInt();
		diags=new int[size];
		usedElems=new int[size];
		if (size %2 ==0)
		{
			pw.println(0);
			pw.flush();
			pw.close();
			return;
		}
		//countRez(0);
		countFinal();
		pw.println(resMas[size]);
		pw.flush();
		pw.close();
	}

}

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

public class D {

    static long MOD = 1000000007L;

    // FROM OEIS
    static long [] table = new long []
        {1, 3, 15, 133, 2025, 37851, 1030367, 36362925};
    //, 1606008513, 87656896891, 5778121715415

    // factorial of 'n' mod MOD
    static long facMod(int n) {
        long ret = 1;
        for (int k=2; k<=n; k++)
            ret = (ret*((long)k))%MOD;
        return ret;
    }

    public static void main(String [] argv) {
        Kattio io = new Kattio(System.in, System.out);
        int n = io.getInt();
        if (n%2 == 0)
            io.println(0);
        else {
            int k = n/2;
            long fromTable = table[k];
            long res = ((fromTable%MOD)*facMod(n))%MOD;
            io.println(res);

        }
        io.close();

    }
}

class Kattio extends PrintWriter {
    public Kattio(InputStream i) {
        super(new BufferedOutputStream(System.out));
        r = new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(InputStream i, OutputStream o) {
        super(new BufferedOutputStream(o));
        r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
        return peekToken() != null;
    }

    public int getInt() {
        return Integer.parseInt(nextToken());
    }

    public double getDouble() {
        return Double.parseDouble(nextToken());
    }

    public long getLong() {
        return Long.parseLong(nextToken());
    }

    public String getWord() {
        return nextToken();
    }

    private BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
        if (token == null)
            try {
                while (st == null || !st.hasMoreTokens()) {
                    line = r.readLine();
                    if (line == null) return null;
                    st = new StringTokenizer(line);
                }
                token = st.nextToken();
            } catch (IOException e) { }
        return token;
    }

    private String nextToken() {
        String ans = peekToken();
        token = null;
        return ans;
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] argv) {
		MainRun mainSolve = new MainRun();
		mainSolve.run(0, 0);
	}
}

class Task {
	long ans = 0;
	final int modulo = 1000000007;
	void rec(int curPos, int n, boolean used[], boolean usedC[]) {
		if (curPos > n)
			ans++;
		else {
			for (int i = 1; i <= n; i++) {
				int C = (curPos - 1 + i - 1) % n + 1;
				if (used[i] == false && usedC[C] == false) {
					used[i] = true;
					usedC[C] = true;
					rec(curPos + 1, n, used, usedC);
					used[i] = false;
					usedC[C] = false;
				}
			}
		}
	}
	public void solve(InputReader in, PrintWriter out) {
		int n = in.nextInt();
		if ((n & 1) == 0) {
			out.println("0");
			return;
		}
		if (n >= 13) {
			if (n == 13)
				out.println(695720788);
			else
				out.println(150347555);
			return;
		}
		boolean used[] = new boolean[n + 2];
		rec(1, n, used, new boolean[n + 2]);
		ans %= modulo;
		for (int i = 1; i <= n; i++)
			ans = (ans * i) % modulo;
		out.println(ans);
	}
}

class MainRun {
	void run(int inF, int outF) {
//		inF = outF = 0;
		String input = "input.txt";
		String output = "output.txt";
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in;
		PrintWriter out;
		if (inF == 1)
			in = new InputReader(input);
		else
			in = new InputReader(inputStream);
		if (outF == 1)
			out = getPrintWriter(output);
		else
			out = getPrintWriter(outputStream);
		Task solver = new Task();
		solver.solve(in, out);
		out.close();
	}
	public static PrintWriter getPrintWriter(OutputStream stream) {
		return new PrintWriter(stream);
	}
	public static PrintWriter getPrintWriter(String f) {
		try {
			return new PrintWriter(new File(f));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}

class InputReader {
	BufferedReader reader;
	StringTokenizer tokenizer;
	InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream));
		tokenizer = null;
	}
	InputReader(String f) {
		try {
			reader = new BufferedReader(new FileReader(f));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		tokenizer = null;
	}
	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
	public long nextLong() {
		return Long.parseLong(next());
	}
	public double nextDouble() {
		return Double.parseDouble(next());
	}
	public int[] nextIntArray(int n) {
		int a[] = new int[n + 2];
		for (int i = 1; i <= n; i++)
			a[i] = nextInt();
		return a;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class MainD {

    FastScanner in;
    PrintWriter out;

    int[] a = new int[] { 1, 3, 15, 133, 2025, 37851, 1030367, 36362925 };

    public void solve() throws IOException {
        int n = in.nextInt();
        if (n % 2 == 0) {
            out.println(0);
            return;
        }
        long res = a[n / 2];
        for (int i = 1; i <= n; i++) {
            res = (res * i) % 1000000007;
        }
        out.println(res);
    }

    public void run() {
        try {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
            solve();
            out.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public static void main(String[] arg) {
        new MainD().run();
    }
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Diego Huerfano ( diego.link )
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        final int n=in.readInt();
        if( n%2==0 ) {
            out.printLine( 0 );
            return;
        }
        long MODULO=(int)1e9+7;
        int precalculate[]={1, 3, 15, 133, 2025, 37851, 1030367, 36362925, 1606008513};
        long factorial=1;
        for( int i=2; i<=n; i++ ) {
            factorial*=i;
            factorial%=MODULO;
        }
        out.printLine( precalculate[n/2]*factorial%MODULO );
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object...objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object...objects) {
        print( objects );
        writer.println();
    }

    public void close() {
        writer.close();
    }
}

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

public class D {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	// int n;
	//
	// boolean[] b;
	// boolean[] c;
	//
	// int go(int pos) {
	// if (pos == n)
	// return 1;
	// int ret = 0;
	// for (int bVal = 0; bVal < n; bVal++)
	// if (!b[bVal]) {
	// int cVal = pos + bVal;
	// if (cVal >= n)
	// cVal -= n;
	// if (!c[cVal]) {
	// b[bVal] = c[cVal] = true;
	// ret += go(pos + 1);
	// b[bVal] = c[cVal] = false;
	// }
	// }
	// return ret;
	// }

	static final int[] ANS = { 1, 3, 15, 133, 2025, 37851, 1030367, 36362925 };
	static final int MOD = 1_000_000_007;

	void solve() throws IOException {
		// this.n = n;
		// b = new boolean[n];
		// c = new boolean[n];
		//
		// int ans = go(0);
		// System.err.println(n + " -> " + ans);

		int n = nextInt();
		if (n % 2 == 0) {
			out.println(0);
		} else {
			int ans = ANS[n / 2];
			for (int i = 1; i <= n; i++)
				ans = (int)((long)ans * i % MOD);
			out.println(ans);
		}
	}

	D() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		// for (int n = 1; n <= 16; n++)
		// solve(n);
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new D();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

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

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

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

import static java.lang.System.*;
import static java.lang.Math.*;
import java.util.*;

public class D285{
    public static Scanner sc = new Scanner(in);
    public static Random rand=new Random();
    public class Permutation implements Iterable<int[]> {
        private final int size;
        public Permutation(int size) {
            if (size <= 0) throw new IllegalArgumentException();
            this.size = size;
        }
        public Iterator<int[]> iterator() {
            return new Iter(size);
        }

        private class Iter implements Iterator<int[]> {
            private final int[] source;
            private final int[] end;
            private boolean isFirst=true;
            private int size;

            private Iter(int size) {
                source = new int[size];
                end=new int[size];
                this.size=size;
                for(int i = 0; i < size; ++i) {
                    source[i] = i;
                    end[size-i-1]=i;
                }
            }
            public boolean hasNext() {
                if(isFirst && size==1){
                    return true;
                }
                for (int i = 0; i < source.length; i++) {
                    if(source[i]!=end[i]){
                        return true;
                    }
                }
                return false;
            }
            public int[] next() {
                if(isFirst){
                    isFirst=false;
                    return source;
                }

                int n = source.length;
                for (int i = n - 1; i > 0; i--) {
                    if (source[i - 1] < source[i]) {
                        int j = n;
                        while (source[i - 1] >= source[--j]);
                        swap(source, i - 1, j);
                        reverse(source, i, n);
                        return source;
                    }
                }
                reverse(source, 0, n);
                return source;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
            private void swap(int[] is, int i, int j) {
                int t = is[i];
                is[i] = is[j];
                is[j] = t;
            }

            private void reverse(int[] is, int s, int t) {
                while (s < --t) swap(is, s++, t);
            }
        }
    }

    int mod=1000000007;
    public void run(){

        int n=sc.nextInt();
        if(n%2==0){
            ln(0);
            return;
        }
        long res=1;
        //BigInteger res=new BigInteger(1+"");
        for(int i=1;i<=n;i++){
            //res=res.pow(i);
            res=(i*res)%mod;
        }
//      Permutation p=new Permutation(n);
//      boolean[] ex=new boolean[n];
//      long c=0;
//      loop:for(int[] a:p){
//          Arrays.fill(ex,false);
//          for(int i=0;i<a.length;i++){
//              if(ex[(a[i]+i)%n])
//                  continue loop;
//              ex[a[i]]=true;
//          }
//          c++;
//      }
////
////        for(int i=1;i<=n;i+=2){
//          res=(i*res)%mod;
//      }
        //ln(c);
        int[] c=new int[]{0,1,0,3,0,15,0,133,0,2025,0,37851,0,1030367,0,36362925,0};

        ln((res*c[n])%mod);
    }

    public static void main(String[] _) {
        new D285().run();
    }

    public int[] nextIntArray(int n){
        int[] res=new int[n];
        for(int i=0;i<n;i++){
            res[i]=sc.nextInt();
        }
        return res;
    }
    public static void pr(Object o) {
        out.print(o);
    }
    public static void ln(Object o) {
        out.println(o);
    }
    public static void ln() {
        out.println();
    }

}

import java.util.Scanner;

// http://codeforces.com/contest/285/problem/D
public class PermutationSum {
    static final int MD = 1000000007;

    static int n;

    static int n2;

    static int nn;

    static int nnm;

    static long nf;

    static long total;

    static int[] a;

    static int[] map;

    static short[][] memo;

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        n = s.nextInt();
        if (n % 2 == 1) {
            n2 = n / 2;
            nn = 1 << n;
            nnm = nn - 1;
            map = new int[nn];
            fact();
            init();
            permutation(0, 0, 0, n2 + 1, n2, true);
            permutation(0, 0, 0, 0, n2 + 1, false);
            total %= MD;
            total *= nf;
            total %= MD;
        }
        System.out.println(total);
        s.close();
    }

    public static void fact() {
        nf = 1;
        for (int i = 2; i <= n; i++) {
            nf *= i;
            nf %= MD;
        }
    }

    public static void init() {
        a = new int[n];
        for (int i = 1; i < n; i++) {
            a[i] = i;
        }
        int count = 0;
        for (int i = 0; i < nn; i++) {
            if (Integer.bitCount(i) == n2) {
                count++;
            }
        }
        memo = new short[count][count];
        count = 0;
        for (int i = 0; i < nn; i++) {
            if (Integer.bitCount(i) == n2) {
                map[i] = count++;
            }
        }
    }

    static void permutation(int idx, int mask1, int mask2, int cmp, int cnt, boolean save) {
        if (cnt == 0) {
            if (save) {
                memo[map[mask1]][map[mask2]]++;
            } else {
                int m1 = map[nnm ^ mask1];
                int m2 = map[nnm ^ mask2];
                total += memo[m1][m2];
            }
            return;
        }
        for (int i = idx; i < n; i++) {
            swap(idx, i);
            int b = (idx + cmp + a[idx]) >= n ? (idx + cmp + a[idx] - n) : (idx + cmp + a[idx]);
            int ii = 1 << b;
            int mm = 1 << a[idx];
            if ((ii & mask2) == 0) {
                permutation(idx + 1, mask1 | mm, mask2 | ii, cmp, cnt - 1, save);
            }
            swap(idx, i);
        }
    }

    static void swap(int i, int j) {
        if (i != j) {
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

}

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    static String[] ans = {
            "1",
            "1",
            "0",
            "18",
            "0",
            "1800",
            "0",
            "670320",
            "0",
            "734832000",
            "0",
            "1510890796800",
            "0",
            "6416116740633600",
            "0",
            "47550864968006400000",
            "0",
    };

    public static void main(String[] args) {
        System.out.println(new BigInteger(ans[Integer.parseInt(new Scanner(System.in).nextLine())]).mod(new BigInteger("1000000007")));
    }
}

import java.util.Scanner;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long k = 1;
        for (int i = 2; i <= n; i++)
            k *= i;
        k *= k;

        long b = 1;
        for (int i = 3; i <= n; i++)
            b *= 2;

        System.out.println((k / b) % 1000000007);
    }
}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import static java.lang.Math.*;
import static java.lang.Integer.*;

@SuppressWarnings("unused")
public class round175D {

    static BufferedReader br = new BufferedReader(new InputStreamReader(
            System.in));
    static StringTokenizer st = new StringTokenizer("");

    static int nextInt() throws Exception {
        return Integer.parseInt(next());
    }

    static String next() throws Exception {
        while (true) {
            if (st.hasMoreTokens()) {
                return st.nextToken();
            }
            String s = br.readLine();
            if (s == null) {
                return null;
            }
            st = new StringTokenizer(s);
        }
    }

    static int n;
    static int mod = (int) (1e9 + 7);
    static int[] sol = new int[] { 1, 3, 15, 133, 2025, 37851, 1030367,
            36362925 };

    public static int factorial(int n) {
        if (n == 0)
            return 1;
        return (n * factorial(n - 1)) % mod;
    }

    public static int get(int mask1, int mask2) {
        if (bitCount(mask1) == n && bitCount(mask2) == n)
            return 1;
        int turn = bitCount(mask1);
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (((mask1 >> i) & 1) == 1)
                continue;
            int ansBit = ((i + turn) % n) + 1;
            if (((mask2 >> ansBit) & 1) == 1)
                continue;
            ans += get(mask1 | (1 << i), mask2 | (1 << ansBit));
        }
        return ans;
    }

    public static void main(String[] args) throws Exception {
        n = nextInt();
        if (n % 2 == 0) {
            System.out.println(0);
        } else {
            if (n == 1) {
                System.out.println(1);
            } else {
                long fact = factorial(n);
                System.out.println((fact * sol[n / 2]) % mod);
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

	static final int mod = (int)1e9 + 7;
	static int n;

	static int f(int i, int usedB, int usedC)
	{
		if(i == n)
			return 1;
		int ret = 0;
		for(int j = 0; j < n; ++j)
			if((usedB & 1 << j) == 0 && (usedC & 1 << (i + j) % n) == 0)
				ret = (ret + f(i + 1, usedB | 1 << j, usedC | 1 << (i + j) % n)) % mod;
		return ret;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

//		n = sc.nextInt();
//		long[] fac = new long[n + 1];
//		fac[0] = 1;
//		for(int i = 1; i <= n; ++i)
//			fac[i] = i * fac[i - 1] % mod;
//		out.println(fac[n] * f(0, 0, 0) % mod);

		int[] ans = {1,	0, 18, 0, 1800, 0, 670320, 0, 744629760, 0,	734832000, 0, 695720788, 0, 150347555, 0};
		out.println(ans[sc.nextInt() - 1]);
		out.flush();
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException { return Double.parseDouble(next()); }

		public boolean ready() throws IOException {return br.ready();}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

	static final int mod = (int)1e9 + 7;
	static int[] memo;
	static int n;

	static int dp(int msk, int circ)
	{
		int i = Integer.bitCount(msk);
		if(i == n)
			return 1;
		int state = get(msk, circ);
		if(memo[state] != -1)
			return memo[state];
		int ret = 0;
		for(int j = 0; j < n; ++j)
			if((msk & 1 << j) == 0 && (circ & 1 << j) == 0)
			{
				int nxtCirc = circ | 1 << j;
				ret += dp(msk | 1 << j, ((nxtCirc & 1) << n - 1) | (nxtCirc >> 1));
				ret %= mod;
			}
		return memo[state] = ret;
	}

	static int get(int msk, int circ)
	{
		int s = 0;
		for(int i = 0, c = 0, f = 1; i < n; ++i, f *= 3)
		{
			int x = ((msk >> i & 1) + (circ >> i & 1) + c);
			s = s + x % 3 * f;
			c = x / 3;
		}
		return s;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

//		for(int j = 1; j <= 16; ++j)
//		{
//			n = j;
//			memo = new int[43046721];
//			Arrays.fill(memo, -1);
//			long[] fac = new long[n + 1];
//			fac[0] = 1;
//			for(int i = 1; i <= n; ++i)
//				fac[i] = i * fac[i - 1] % mod;
//			if(n % 2 == 0)
//				out.print("0, ");
//			else
//				out.print(fac[n] * dp(0, 0) % mod + ", ");
//		}
		int[] ans = {1,	0, 18, 0, 1800, 0, 670320, 0, 744629760, 0,	408021283, 0, 286510150, 0, 335881150, 0};
		out.println(ans[sc.nextInt() - 1]);
		out.flush();
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException { return Double.parseDouble(next()); }

		public boolean ready() throws IOException {return br.ready();}
	}
}

import java.util.Map;
import java.io.IOException;
import java.util.TreeMap;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    final int MOD = (int) (1e9) + 7;
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        Map<Long, Integer> mp = new TreeMap<Long, Integer>();
        int n = in.readInt();
        if (n > 9) {
            out.println(0);
            return;
        }

        long[] fact = new long[n + 1];
        fact[0] = 1;
        for (int i = 1; i <= n; ++i) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        long res = go(0, 0, 0, mp, n);
        res *= fact[n];
        res %= MOD;

        out.println(res);
    }

    long marge (long s1, long s2, int n) {
        long res = (s1 << n) | s2;
        return res;
    }

    private int go(int i, int s2, int s3, Map<Long, Integer> mp, int n) {
        long state = marge(s2, s3, n);
        if (mp.containsKey(state)) {
            return mp.get(state);
        }
        if (i == n) {
            mp.put(state, 1);
            return mp.get(state);
        }
        int res = 0;
        for (int j = 0; j < n; ++j) {
            if (Bits.IsSet(s2, j)) continue;
            int b = (i + j) % n + 1;
            if (Bits.IsSet(s3, b)) continue;
            int temp = go(i + 1, s2 | (1 << j), s3 | (1 << b), mp, n);
            res = (res + temp) % MOD;
        }
        mp.put(state, res);
        return res;
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        // InputMismatchException -> UnknownError
        if (numChars == -1)
            throw new UnknownError();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new UnknownError();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        } else if (c == '+') {
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }

class Bits {

    public static boolean IsSet(int n, int i) {
        return (n & (1 << i)) > 0;
    }

    }

import java.util.Map;
import java.io.IOException;
import java.util.TreeMap;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    final int MOD = (int) (1e9) + 8;
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        Map<Long, Integer> mp = new TreeMap<Long, Integer>();
        int n = in.readInt();
        if (n > 9) {
            out.println(0);
            return;
        }

        long[] fact = new long[n + 1];
        fact[0] = 1;
        for (int i = 1; i <= n; ++i) {
            fact[i] = (fact[i - 1] * i) % MOD;
        }

        long res = go(0, 0, 0, mp, n);
        res *= fact[n];
        res %= MOD;

        out.println(res);
    }

    long marge (long s1, long s2, int n) {
        long res = (s1 << n) | s2;
        return res;
    }

    private int go(int i, int s2, int s3, Map<Long, Integer> mp, int n) {
        long state = marge(s2, s3, n);
        if (mp.containsKey(state)) {
            return mp.get(state);
        }
        if (i == n) {
            mp.put(state, 1);
            return mp.get(state);
        }
        int res = 0;
        for (int j = 0; j < n; ++j) {
            if (Bits.IsSet(s2, j)) continue;
            int b = (i + j) % n + 1;
            if (Bits.IsSet(s3, b)) continue;
            int temp = go(i + 1, s2 | (1 << j), s3 | (1 << b), mp, n);
            res = (res + temp) % MOD;
        }
        mp.put(state, res);
        return res;
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        // InputMismatchException -> UnknownError
        if (numChars == -1)
            throw new UnknownError();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new UnknownError();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        } else if (c == '+') {
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }

class Bits {

    public static boolean IsSet(int n, int i) {
        return (n & (1 << i)) > 0;
    }

    }

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
  private static BufferedReader br;
  private static StringTokenizer st;
  private static PrintWriter pw;

  public static void main(String[] args) throws IOException {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    //int qq = 1;
    int qq = Integer.MAX_VALUE;
    //int qq = readInt();
    long[] ret = new long[]{1,3,15,133,2025,37851,1030367,36362925};
    long[] fact = new long[16];
    fact[0] = 1;
    for(int i = 1; i < fact.length; i++) {
      fact[i] = fact[i-1] * i;
    }
    for(int casenum = 1; casenum <= qq; casenum++)  {
      int num = readInt();
      if(num%2==0) {
        pw.println(0);
      }
      else {
        pw.println((ret[num/2] * fact[num]) % 1000000007);
      }
    }
    pw.close();
  }

  private static void exitImmediately() {
    pw.close();
    System.exit(0);
  }

  private static long readLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  private static double readDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  private static int readInt() throws IOException {
    return Integer.parseInt(nextToken());
  }

  private static String nextToken() throws IOException  {
    while(st == null || !st.hasMoreTokens())  {
      if(!br.ready()) {
        exitImmediately();
      }
      st = new StringTokenizer(br.readLine().trim());
    }
    return st.nextToken();
  }
}

import java.util.*;
import java.io.*;
public class a {
  static long mod = 1000000007;
public static void main(String[] args) throws IOException
{
  input.init(System.in);
  PrintWriter out = new PrintWriter(new PrintStream(System.out));
  //input.init(new FileInputStream(new File("input.txt")));
  //PrintWriter out = new PrintWriter(new File("output.txt"));
  int n = input.nextInt();
  long[] data = new long[17];
  data[0] = 0;
  data[1] = 1;
  for(int i = 2; i<=16; i++)
  {
    data[i] = (data[i-2] * (i*i*(i-1)))%mod;
  }
  out.println(data[n]);

  out.close();
}
static long gcd(long a, long b)
{
  if(b==0) return a;
  return gcd(b, a%b);
}
static long pow(long a, long p)
{
  if(p<=0) return 1;
  if((p&1) == 0)
  {
    long sqrt = pow(a, p/2);
    return (sqrt*sqrt)%mod;
  }
  else
    return (a*pow(a,p-1))%mod;
}
static class input {
  static BufferedReader reader;
  static StringTokenizer tokenizer;

  /** call this method to initialize reader for InputStream */
  static void init(InputStream input) {
      reader = new BufferedReader(
                   new InputStreamReader(input) );
      tokenizer = new StringTokenizer("");
  }

  /** get next word */
  static String next() throws IOException {
      while ( ! tokenizer.hasMoreTokens() ) {
          //TODO add check for eof if necessary
          tokenizer = new StringTokenizer(
                 reader.readLine() );
      }
      return tokenizer.nextToken();
  }

  static int nextInt() throws IOException {
      return Integer.parseInt( next() );
  }
  static long nextLong() throws IOException {
    return Long.parseLong( next() );
}

  static double nextDouble() throws IOException {
      return Double.parseDouble( next() );
  }
  static String nextLine() throws IOException {
    return reader.readLine();
  }
}
}

import java.util.*;
import java.math.*;
import java.io.*;

public class Main
	{
	public static void main(String args[]) throws IOException
		{
		int A[]=new int[]{0,1,0,3,0,15,0,133,0,2025,0,37851,0,1030367,0,36362925,0};
		InputReader in=new InputReader(System.in);
		int N=in.readInt();
		long mod=1000000009;
		System.out.println(((fact(N)%mod)*A[N])%mod);
		}

	public static long fact(int n)
		{
		long ans=1;
		for(int i=1;i<=n;i++)
			ans*=i;
		return ans;
		}
	}

class InputReader
	{
	private InputStream stream;
	private byte[] buf=new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream)
		{
		this.stream=stream;
		}

	public int read()
		{
		if(numChars==-1)
			throw new InputMismatchException();
		if(curChar>=numChars)
			{
			curChar=0;
			try
				{
				numChars=stream.read(buf);
				} catch (IOException e)
				{
				throw new InputMismatchException();
				}
			if(numChars<=0)
				return -1;
			}
		return buf[curChar++];
		}

	public int readInt()
		{
		int c=read();
		while (isSpaceChar(c))
			c=read();
		int sgn=1;
		if(c=='-')
			{
			sgn=-1;
			c=read();
			}
		int res=0;
		do
			{
			if(c<'0'||c>'9')
				throw new InputMismatchException();
			res*=10;
			res+=c-'0';
			c=read();
			} while (!isSpaceChar(c));
		return res*sgn;
		}

	public boolean isSpaceChar(int c)
		{
		if(filter!=null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
		}

	public static boolean isWhitespace(int c)
		{
		return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
		}

	public char readCharacter()
		{
		int c=read();
		while (isSpaceChar(c))
			c=read();
		return (char) c;
		}

	public interface SpaceCharFilter
		{
		public boolean isSpaceChar(int ch);
		}
	}

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main (String []args) throws IOException{
		Scanner in = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int n = in.nextInt();
		BigInteger b[] = new BigInteger[30];
		b[0] = BigInteger.ONE;
		for(int i=1; i<=n; i++)
			b[i] = b[i-1].multiply(BigInteger.valueOf(i));
		int a[] = { 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 121275, 0};
		if(n%2==0) pw.print('0');
		else if(n!=15 && n!=13){
			pw.print(b[n].multiply(BigInteger.valueOf(a[n-1])).mod(BigInteger.valueOf(1000000007)));
		}
		else if(n==13){
			BigInteger x = BigInteger.valueOf(a[n-3]/(n-2)).multiply(BigInteger.valueOf((n-4)*(n-4)));
			x = x.multiply(BigInteger.valueOf(n));
			pw.print(b[n].multiply(x).mod(BigInteger.valueOf(1000000007)));
		}
		else {
			BigInteger x = BigInteger.valueOf(a[n-5]/(n-4)).multiply(BigInteger.valueOf((n-4)*(n-4)*(n-6)*n-6));
			x = x.multiply(BigInteger.valueOf(n));
			pw.print(b[n].multiply(x).mod(BigInteger.valueOf(1000000007)));
		}
		pw.close();
	}
}

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main (String []args) throws IOException{
		Scanner in = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int n = in.nextInt();
		BigInteger b[] = new BigInteger[30];
		b[0] = BigInteger.ONE;
		for(int i=1; i<=n; i++)
			b[i] = b[i-1].multiply(BigInteger.valueOf(i));
		int a[] = { 1, 0, 3, 0, 15, 0, 133, 0, 2025, 0, 194579, 0, 53308125, 0};
		if(n%2==0) pw.print('0');
		else if(n!=15){
			pw.print(b[n].multiply(BigInteger.valueOf(a[n-1])).mod(BigInteger.valueOf(1000000007)));
		}
		else {
			BigInteger x = BigInteger.valueOf(a[12]).pow(2);
			x = x.multiply(BigInteger.valueOf(15));
			pw.print(b[n].multiply(x).mod(BigInteger.valueOf(1000000007)));
		}
		pw.close();
	}
}

import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class D {

	final static boolean autoflush = false;

	final static int MOD = (int) 1e9 + 7;
	final static double eps = 1e-9;
	final static int INF = (int) 1e9;

	long [] res = { 0, 1, 0, 18, 0, 1800, 0, 670320, 0, 595486080, 0, 148107101, 0, 875700050, 0, 978876668, 0 };

	public D () {
		exit(res[sc.nextInt()]);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static int [] rep(int N) { return rep(0, N); }
	static int [] rep(int S, int T) { int [] res = new int [max(T-S, 0)]; for (int i = S; i < T; ++i) res[i-S] = i; return res; }
	static int [] req(int S, int T) { return rep(S, T+1); }

	////////////////////////////////////////////////////////////////////////////////////

	/* Dear hacker, don't bother reading below this line, unless you want to help me debug my I/O routines :-) */

	final static MyScanner sc = new MyScanner();

	static class MyScanner {
		public String next() {
			newLine();
			return line[index++];
		}

		public char nextChar() {
			return next().charAt(0);
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public String nextLine() {
			line = null;
			return readLine();
		}

		public String [] nextStrings() {
			line = null;
			return readLine().split(" ");
		}

		public char [] nextChars() {
			return next ().toCharArray ();
		}

		public Integer [] nextInts() {
			String [] L = nextStrings();
			Integer [] res = new Integer [L.length];
			for (int i : rep(L.length))
				res[i] = Integer.parseInt(L[i]);
			return res;
		}

		public Long [] nextLongs() {
			String [] L = nextStrings();
			Long [] res = new Long [L.length];
			for (int i : rep(L.length))
				res[i] = Long.parseLong(L[i]);
			return res;
		}

		public Double [] nextDoubles() {
			String [] L = nextStrings();
			Double [] res = new Double [L.length];
			for (int i : rep(L.length))
				res[i] = Double.parseDouble(L[i]);
			return res;
		}

		public String [] next (int N) {
			String [] res = new String [N];
			for (int i : rep(N))
				res[i] = sc.next();
			return res;
		}

		public Integer [] nextInt (int N) {
			Integer [] res = new Integer [N];
			for (int i : rep(N))
				res[i] = sc.nextInt();
			return res;
		}

		public Long [] nextLong (int N) {
			Long [] res = new Long [N];
			for (int i : rep(N))
				res[i] = sc.nextLong();
			return res;
		}

		public Double [] nextDouble (int N) {
			Double [] res = new Double [N];
			for (int i : rep(N))
				res[i] = sc.nextDouble();
			return res;
		}

		public String [][] nextStrings (int N) {
			String [][] res = new String [N][];
			for (int i : rep(N))
				res[i] = sc.nextStrings();
			return res;
		}

		public Integer [][] nextInts (int N) {
			Integer [][] res = new Integer [N][];
			for (int i : rep(N))
				res[i] = sc.nextInts();
			return res;
		}

		public Long [][] nextLongs (int N) {
			Long [][] res = new Long [N][];
			for (int i : rep(N))
				res[i] = sc.nextLongs();
			return res;
		}

		public Double [][] nextDoubles (int N) {
			Double [][] res = new Double [N][];
			for (int i : rep(N))
				res[i] = sc.nextDoubles();
			return res;
		}

		//////////////////////////////////////////////

		private boolean eol() {
			return index == line.length;
		}

		private String readLine() {
			try {
				return r.readLine();
			} catch (Exception e) {
				throw new Error (e);
			}
		}
		private final java.io.BufferedReader r;

		MyScanner () {
			this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in)));
		}

		MyScanner (java.io.BufferedReader r) {
			try {
				this.r = r;
				while (!r.ready())
					Thread.sleep(1);
				start();
			} catch (Exception e) {
				throw new Error(e);
			}
		}

		private String [] line;
		private int index;

		private void newLine() {
			if (line == null || eol()) {
				line = readLine().split(" ");
				index = 0;
			}
		}
	}

	static void print (Object o, Object... a) {
		printDelim(" ", o, a);
	}

	static void cprint (Object o, Object... a) {
		printDelim("", o, a);
	}

	static void printDelim (String delim, Object o, Object... a) {
		pw.println(build(delim, o, a));
	}

	static void exit (Object o, Object... a) {
		print(o, a);
		exit();
	}

	static void exit() {
		pw.close();
		System.out.flush();
		System.err.println("------------------");
		System.err.println("Time: " + ((millis() - t) / 1000.0));
		System.exit(0);
	}

	static void NO() {
		throw new Error("NO!");
	}

	////////////////////////////////////////////////////////////////////////////////////

	static String build (String delim, Object o, Object... a) {
		StringBuilder b = new StringBuilder();
		append(b, o, delim);
		for (Object p : a)
			append(b, p, delim);
		return b.toString().trim();
	}

	static void append(StringBuilder b, Object o, String delim) {
		if (o.getClass().isArray()) {
			int L = java.lang.reflect.Array.getLength(o);
			for (int i : rep(L))
				append(b, java.lang.reflect.Array.get(o, i), delim);
		} else if (o instanceof Iterable<?>)
			for (Object p : (Iterable<?>)o)
				append(b, p, delim);
		else
			b.append(delim).append(o);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static void statics() {
		abs(0);
		valueOf(0);
		asList(new Object [0]);
		reverseOrder();
	}

	public static void main (String[] args) {
		new D();
		exit();
	}

	static void start() {
		t = millis();
	}

	static java.io.PrintWriter pw = new java.io.PrintWriter(System.out, autoflush);

	static long t;

	static long millis() {
		return System.currentTimeMillis();
	}
}

import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class D {

	final static boolean autoflush = false;

	final static int MOD = (int) 1e9 + 7;
	final static double eps = 1e-9;
	final static int INF = (int) 1e9;

	long [] res = { 0, 1, 0, 18, 0, 1800, 0, 640080, 0, 539602560, 0, 23723306, 0, 337153085, 0, 753471757, 0 };

	public D () {
		exit(res[sc.nextInt()]);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static int [] rep(int N) { return rep(0, N); }
	static int [] rep(int S, int T) { int [] res = new int [max(T-S, 0)]; for (int i = S; i < T; ++i) res[i-S] = i; return res; }
	static int [] req(int S, int T) { return rep(S, T+1); }

	////////////////////////////////////////////////////////////////////////////////////

	/* Dear hacker, don't bother reading below this line, unless you want to help me debug my I/O routines :-) */

	final static MyScanner sc = new MyScanner();

	static class MyScanner {
		public String next() {
			newLine();
			return line[index++];
		}

		public char nextChar() {
			return next().charAt(0);
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public String nextLine() {
			line = null;
			return readLine();
		}

		public String [] nextStrings() {
			line = null;
			return readLine().split(" ");
		}

		public char [] nextChars() {
			return next ().toCharArray ();
		}

		public Integer [] nextInts() {
			String [] L = nextStrings();
			Integer [] res = new Integer [L.length];
			for (int i : rep(L.length))
				res[i] = Integer.parseInt(L[i]);
			return res;
		}

		public Long [] nextLongs() {
			String [] L = nextStrings();
			Long [] res = new Long [L.length];
			for (int i : rep(L.length))
				res[i] = Long.parseLong(L[i]);
			return res;
		}

		public Double [] nextDoubles() {
			String [] L = nextStrings();
			Double [] res = new Double [L.length];
			for (int i : rep(L.length))
				res[i] = Double.parseDouble(L[i]);
			return res;
		}

		public String [] next (int N) {
			String [] res = new String [N];
			for (int i : rep(N))
				res[i] = sc.next();
			return res;
		}

		public Integer [] nextInt (int N) {
			Integer [] res = new Integer [N];
			for (int i : rep(N))
				res[i] = sc.nextInt();
			return res;
		}

		public Long [] nextLong (int N) {
			Long [] res = new Long [N];
			for (int i : rep(N))
				res[i] = sc.nextLong();
			return res;
		}

		public Double [] nextDouble (int N) {
			Double [] res = new Double [N];
			for (int i : rep(N))
				res[i] = sc.nextDouble();
			return res;
		}

		public String [][] nextStrings (int N) {
			String [][] res = new String [N][];
			for (int i : rep(N))
				res[i] = sc.nextStrings();
			return res;
		}

		public Integer [][] nextInts (int N) {
			Integer [][] res = new Integer [N][];
			for (int i : rep(N))
				res[i] = sc.nextInts();
			return res;
		}

		public Long [][] nextLongs (int N) {
			Long [][] res = new Long [N][];
			for (int i : rep(N))
				res[i] = sc.nextLongs();
			return res;
		}

		public Double [][] nextDoubles (int N) {
			Double [][] res = new Double [N][];
			for (int i : rep(N))
				res[i] = sc.nextDoubles();
			return res;
		}

		//////////////////////////////////////////////

		private boolean eol() {
			return index == line.length;
		}

		private String readLine() {
			try {
				return r.readLine();
			} catch (Exception e) {
				throw new Error (e);
			}
		}
		private final java.io.BufferedReader r;

		MyScanner () {
			this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in)));
		}

		MyScanner (java.io.BufferedReader r) {
			try {
				this.r = r;
				while (!r.ready())
					Thread.sleep(1);
				start();
			} catch (Exception e) {
				throw new Error(e);
			}
		}

		private String [] line;
		private int index;

		private void newLine() {
			if (line == null || eol()) {
				line = readLine().split(" ");
				index = 0;
			}
		}
	}

	static void print (Object o, Object... a) {
		printDelim(" ", o, a);
	}

	static void cprint (Object o, Object... a) {
		printDelim("", o, a);
	}

	static void printDelim (String delim, Object o, Object... a) {
		pw.println(build(delim, o, a));
	}

	static void exit (Object o, Object... a) {
		print(o, a);
		exit();
	}

	static void exit() {
		pw.close();
		System.out.flush();
		System.err.println("------------------");
		System.err.println("Time: " + ((millis() - t) / 1000.0));
		System.exit(0);
	}

	static void NO() {
		throw new Error("NO!");
	}

	////////////////////////////////////////////////////////////////////////////////////

	static String build (String delim, Object o, Object... a) {
		StringBuilder b = new StringBuilder();
		append(b, o, delim);
		for (Object p : a)
			append(b, p, delim);
		return b.toString().trim();
	}

	static void append(StringBuilder b, Object o, String delim) {
		if (o.getClass().isArray()) {
			int L = java.lang.reflect.Array.getLength(o);
			for (int i : rep(L))
				append(b, java.lang.reflect.Array.get(o, i), delim);
		} else if (o instanceof Iterable<?>)
			for (Object p : (Iterable<?>)o)
				append(b, p, delim);
		else
			b.append(delim).append(o);
	}

	////////////////////////////////////////////////////////////////////////////////////

	static void statics() {
		abs(0);
		valueOf(0);
		asList(new Object [0]);
		reverseOrder();
	}

	public static void main (String[] args) {
		new D();
		exit();
	}

	static void start() {
		t = millis();
	}

	static java.io.PrintWriter pw = new java.io.PrintWriter(System.out, autoflush);

	static long t;

	static long millis() {
		return System.currentTimeMillis();
	}
}

// @author Sanzhar
import java.io.*;
import java.util.*;
import java.awt.Point;

public class Template {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st;

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(in.readLine());
            } catch (Exception e) {
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    public void run() throws Exception {
        //in = new BufferedReader(new FileReader("input.txt"));
        //out = new PrintWriter(new FileWriter("output.txt"));
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.flush();
        out.close();
        in.close();
    }

    public void solve() throws Exception {
        long n = nextLong();
        if (n == 2) {
            out.println(0);
            return;
        }
        long mod = 1000000007;
        long ans = 1;
        for (long i = 1; i <= n; i++) {
            if (i == n - 1) {
                continue;
            }
            ans *= i;
            ans %= mod;
        }
        ans = (2 * ans * ans) % mod;
        out.println(ans);
    }

    public static void main(String[] args) throws Exception {
        new Template().run();
    }
}

// @author Sanzhar
import java.io.*;
import java.util.*;
import java.awt.Point;

public class Template {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st;

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(in.readLine());
            } catch (Exception e) {
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    public void run() throws Exception {
        //in = new BufferedReader(new FileReader("input.txt"));
        //out = new PrintWriter(new FileWriter("output.txt"));
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.flush();
        out.close();
        in.close();
    }

    public void solve() throws Exception {
        long n = nextLong();
        long mod = 1000000007;
        long ans = 1;
        for (long i = 1; i <= n; i++) {
            if (i == n - 1) {
                continue;
            }
            ans *= i;
            ans %= mod;
        }
        ans = (2 * ans * ans) % mod;
        out.println(ans);
    }

    public static void main(String[] args) throws Exception {
        new Template().run();
    }
}

import java.io.*;
import java.util.*;
public class z2 {
	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		int n=in.nextInt();
		long kol=n*n;
		for (int i=n-1;i>0;i--) kol=(kol*i)%1000000007;
		for (int i=n-2;i>0;i-=2) kol=(kol*i)%1000000007;
		System.out.println(kol);
	}
}

import java.io.*;
import java.util.*;
public class z2 {
	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		int n=in.nextInt();
		long kol=n*n;
		if (n%2==0) kol=0;
		for (int i=n-1;i>0;i--) kol=(kol*i)%1000000007;
		for (int i=n-2;i>0;i-=2) kol=(kol*i)%1000000007;
		System.out.println(kol);
	}
}

import java.io.*;
import java.util.*;
public class z2 {
	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		int n=in.nextInt();
		long kol=n*n;
		if (n%2==0) kol=0;
		for (int i=n-1;i>0;i--) kol=(kol*i)%1000000007;
		if (n>3) kol=(kol*(n-2))%1000000007;
		System.out.println(kol);
	}
}

import java.io.*;
import java.util.*;
public class z2 {
	public static int[] b=new int[20];
	public static long fact(long a) {if (a<=1) return 1; else return (a*fact(a-1))%1000000007;}
	public static long peres(int a,int n)
	{
		long ch=0;
		boolean flag;
		if (a>n) return 1; else
		{
			for (int i=1;i<=n;i++)
			{   flag=false;
				for (int j=1;j<a;j++)
				{
					if ((b[j]==i)||((i+a-b[j]-j)%n==0)) {flag=true;break;}
				}
				if (flag) continue;
				b[a]=i;
				ch=(ch+peres(a+1,n))%1000000007;
			}
		}
		return ch;
	}
	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		int n=in.nextInt();
		if (n%2==0) System.out.println(0); else
		if (n==15) System.out.println(150347555); else
		b[1]=1;
		System.out.println((n*fact(n)*peres(2,n))%1000000007L);
	}
}

import java.io.*;
import java.util.*;
public class D {

	long MOD = 1000000007;

    public void solve() throws IOException {
        int n = nextInt();
        if (n == 1) writer.println(1);
        else
        if (n % 2 == 0) writer.println(0);
        else {
        	long ans = 1;
        	for (int i = 1; i <= n; i++) ans = (ans * i) % MOD;
        	ans = (ans * (n - 2) * n) % MOD;
        	writer.println(ans);
        }
    }

    public static void main(String[] args) throws FileNotFoundException {
        new D().run();
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            long tbegin = System.currentTimeMillis();
            reader = new BufferedReader(new InputStreamReader(System.in));
            //reader = new BufferedReader(new InputStreamReader(new FileInputStream("art.in")));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            //writer = new PrintWriter(new FileOutputStream("art.out"));
            solve();
            //reader.close();
            //System.out.println(System.currentTimeMillis() - tbegin + "ms");
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}

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

public class Solution {
    public static void main (String args[]) throws Exception {
        boolean online = "true".equals(System.getProperty("ONLINE_JUDGE"));
        if (online) {
            in = new InputReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        else {
            in = new InputReader(new FileReader("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        }

        new Solution().run();

        out.close();
    }

    void run () {
        int n = in.nextInt();
        long ans = 1;
        for (int i = 1; i <= n; ++i)
            ans = (ans * i) % P;
        for (int i = n; i > 1; i -= 2)
            ans = (ans * i) % P;
        out.println(ans);
    }

    private static final int P = 1000000007;

    private static InputReader in;
    private static PrintWriter out;
}

class InputReader {
    public InputReader(Reader in) {
        buff = new BufferedReader(in);
    }

    public String next () {
        while (str == null || !str.hasMoreTokens())
            try {
                str = new StringTokenizer(buff.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        return str.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(this.next());
    }

    private static BufferedReader buff;
    private static StringTokenizer str;
}

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

public class Solution {
    public static void main (String args[]) throws Exception {
        boolean online = "true".equals(System.getProperty("ONLINE_JUDGE"));
        if (online) {
            in = new InputReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        else {
            in = new InputReader(new FileReader("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        }

        new Solution().run();

        out.close();
    }

    void run () {
        int n = in.nextInt();
        long ans = 1;
        for (int i = 1; i <= n; ++i)
            ans = (ans * i) % P;
        for (int i = n; i >= 0; i -= 2)
            ans = (ans * i) % P;
        out.println(ans);
    }

    private static final int P = 1000000007;

    private static InputReader in;
    private static PrintWriter out;
}

class InputReader {
    public InputReader(Reader in) {
        buff = new BufferedReader(in);
    }

    public String next () {
        while (str == null || !str.hasMoreTokens())
            try {
                str = new StringTokenizer(buff.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        return str.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(this.next());
    }

    private static BufferedReader buff;
    private static StringTokenizer str;
}

import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] argv) {
		MainRun mainSolve = new MainRun();
		mainSolve.run(0, 0);
	}
}

class Task {
	long ans = 0;
	final int modulo = 1000000007;
	void rec(int curPos, int n, boolean used[], boolean usedC[]) {
		if (curPos > n)
			ans++;
		else {
			for (int i = 1; i <= n; i++) {
				int C = (curPos - 1 + i - 1) % n + 1;
				if (used[i] == false && usedC[C] == false) {
					used[i] = true;
					usedC[C] = true;
					rec(curPos + 1, n, used, usedC);
					used[i] = false;
					usedC[C] = false;
				}
			}
		}
	}
	public void solve(InputReader in, PrintWriter out) {
		int n = in.nextInt();
		if ((n & 1) == 0) {
			out.println("-1");
			return;
		}
		if (n >= 13) {
			if (n == 13)
				out.println(695720788);
			else
				out.println(150347555);
			return;
		}
		boolean used[] = new boolean[n + 2];
		rec(1, n, used, new boolean[n + 2]);
		ans %= modulo;
		for (int i = 1; i <= n; i++)
			ans = (ans * i) % modulo;
		out.println(ans);
	}
}

class MainRun {
	void run(int inF, int outF) {
//		inF = outF = 0;
		String input = "input.txt";
		String output = "output.txt";
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in;
		PrintWriter out;
		if (inF == 1)
			in = new InputReader(input);
		else
			in = new InputReader(inputStream);
		if (outF == 1)
			out = getPrintWriter(output);
		else
			out = getPrintWriter(outputStream);
		Task solver = new Task();
		solver.solve(in, out);
		out.close();
	}
	public static PrintWriter getPrintWriter(OutputStream stream) {
		return new PrintWriter(stream);
	}
	public static PrintWriter getPrintWriter(String f) {
		try {
			return new PrintWriter(new File(f));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}

class InputReader {
	BufferedReader reader;
	StringTokenizer tokenizer;
	InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream));
		tokenizer = null;
	}
	InputReader(String f) {
		try {
			reader = new BufferedReader(new FileReader(f));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		tokenizer = null;
	}
	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
	public long nextLong() {
		return Long.parseLong(next());
	}
	public double nextDouble() {
		return Double.parseDouble(next());
	}
	public int[] nextIntArray(int n) {
		int a[] = new int[n + 2];
		for (int i = 1; i <= n; i++)
			a[i] = nextInt();
		return a;
	}
}

import static java.lang.System.*;
import static java.lang.Math.*;
import java.util.*;

public class A285{
    public static Scanner sc = new Scanner(in);
    public static Random rand=new Random();

    int mod=1000000007;
    public void run(){

        int n=sc.nextInt();

        if(n%2==0){
            ln(0);
        }
        long res=1;
        for(int i=1;i<=n;i++){
            res=(i*res)%mod;
        }
        for(int i=1;i<=n;i+=2){
            res=(i*res)%mod;
        }
        ln(res);
    }

    public static void main(String[] _) {
        new A285().run();
    }

    public int[] nextIntArray(int n){
        int[] res=new int[n];
        for(int i=0;i<n;i++){
            res[i]=sc.nextInt();
        }
        return res;
    }
    public static void pr(Object o) {
        out.print(o);
    }
    public static void ln(Object o) {
        out.println(o);
    }
    public static void ln() {
        out.println();
    }

}

import static java.lang.System.*;
import static java.lang.Math.*;
import java.util.*;

public class D285{
    public static Scanner sc = new Scanner(in);
    public static Random rand=new Random();
    public class Permutation implements Iterable<int[]> {
        private final int size;
        public Permutation(int size) {
            if (size <= 0) throw new IllegalArgumentException();
            this.size = size;
        }
        public Iterator<int[]> iterator() {
            return new Iter(size);
        }

        private class Iter implements Iterator<int[]> {
            private final int[] source;
            private final int[] end;
            private boolean isFirst=true;
            private int size;

            private Iter(int size) {
                source = new int[size];
                end=new int[size];
                this.size=size;
                for(int i = 0; i < size; ++i) {
                    source[i] = i;
                    end[size-i-1]=i;
                }
            }
            public boolean hasNext() {
                if(isFirst && size==1){
                    return true;
                }
                for (int i = 0; i < source.length; i++) {
                    if(source[i]!=end[i]){
                        return true;
                    }
                }
                return false;
            }
            public int[] next() {
                if(isFirst){
                    isFirst=false;
                    return source;
                }

                int n = source.length;
                for (int i = n - 1; i > 0; i--) {
                    if (source[i - 1] < source[i]) {
                        int j = n;
                        while (source[i - 1] >= source[--j]);
                        swap(source, i - 1, j);
                        reverse(source, i, n);
                        return source;
                    }
                }
                reverse(source, 0, n);
                return source;
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
            private void swap(int[] is, int i, int j) {
                int t = is[i];
                is[i] = is[j];
                is[j] = t;
            }

            private void reverse(int[] is, int s, int t) {
                while (s < --t) swap(is, s++, t);
            }
        }
    }

    int mod=1000000007;
    public void run(){

        int n=sc.nextInt();
        if(n%2==0){
            ln(0);
        }
        long res=1;
        //BigInteger res=new BigInteger(1+"");
        for(int i=1;i<=n;i++){
            //res=res.pow(i);
            res=(i*res)%mod;
        }
//      Permutation p=new Permutation(n);
//      boolean[] ex=new boolean[n];
//      long c=0;
//      loop:for(int[] a:p){
//          Arrays.fill(ex,false);
//          for(int i=0;i<a.length;i++){
//              if(ex[(a[i]+i)%n])
//                  continue loop;
//              ex[a[i]]=true;
//          }
//          c++;
//      }
////
////        for(int i=1;i<=n;i+=2){
//          res=(i*res)%mod;
//      }
        //ln(c);
        int[] c=new int[]{0,1,0,3,0,15,0,133,0,2025,0,37851,0,1030367,0,36362925,0};

        ln((res*c[n])%mod);
    }

    public static void main(String[] _) {
        new D285().run();
    }

    public int[] nextIntArray(int n){
        int[] res=new int[n];
        for(int i=0;i<n;i++){
            res[i]=sc.nextInt();
        }
        return res;
    }
    public static void pr(Object o) {
        out.print(o);
    }
    public static void ln(Object o) {
        out.println(o);
    }
    public static void ln() {
        out.println();
    }

}

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    static String[] ans = {
            "1",
            "1",
            "0",
            "18",
            "0",
            "1800",
            "0",
            "670320",
            "0",
            "734832000",
            "0",
            "1510890796800",
            "0",
            "6416116740633600",
            "0",
            "47550864968006400000",
            "0",
    };

    public static void main(String[] args) {
        System.out.println(new BigInteger(ans[Integer.parseInt(new Scanner(System.in).nextLine())]).mod(new BigInteger("1000000009")));
    }
}