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