One day, $$$n$$$ people ($$$n$$$ is an even number) met on a plaza and made two round dances, each round dance consists of exactly $$$\frac{n}{2}$$$ people. Your task is to find the number of ways $$$n$$$ people can make two round dances if each round dance consists of exactly $$$\frac{n}{2}$$$ people. Each person should belong to exactly one of these two round dances.Round dance is a dance circle consisting of $$$1$$$ or more people. Two round dances are indistinguishable (equal) if one can be transformed to another by choosing the first participant. For example, round dances $$$[1, 3, 4, 2]$$$, $$$[4, 2, 1, 3]$$$ and $$$[2, 1, 3, 4]$$$ are indistinguishable.For example, if $$$n=2$$$ then the number of ways is $$$1$$$: one round dance consists of the first person and the second one of the second person.For example, if $$$n=4$$$ then the number of ways is $$$3$$$. Possible options:  one round dance — $$$[1,2]$$$, another — $$$[3,4]$$$;  one round dance — $$$[2,4]$$$, another — $$$[3,1]$$$;  one round dance — $$$[4,1]$$$, another — $$$[3,2]$$$. Your task is to find the number of ways $$$n$$$ people can make two round dances if each round dance consists of exactly $$$\frac{n}{2}$$$ people.

The input contains one integer $$$n$$$ ($$$2 \le n \le 20$$$), $$$n$$$ is an even number.

Print one integer — the number of ways to make two round dances. It is guaranteed that the answer fits in the $$$64$$$-bit integer data type.

import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Upsolve2 {
    //code written by a living bruh moment
    public static void main(String[] args) throws IOException {
        Reader in = new Reader();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        int t = 1;
        for (int tt = 1; tt <= t; tt++) solver.solve(tt, in, out);
        in.close();
        out.close();
    }

    static class Task {

        public void solve(int tt, Reader in, PrintWriter out) throws IOException {
            int n = in.nextInt();
            long[] a = {0,2,24,720,40320,3628800,479001600,87178291200L,20922789888000L,6402373705728000L,2432902008176640000L};
            out.println(a[n/2]/n/(n/2));
        }
    }

    static void sort(int[] x) {
        shuffle(x);
        Arrays.sort(x);
    }

    static void sort(long[] x) {
        shuffle(x);
        Arrays.sort(x);
    }

    static void shuffle(int[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            int temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static void shuffle(long[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            long temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
        StringTokenizer tokenizer;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String nextLine() throws IOException {
            byte[] buf = new byte[360]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

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

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }

        public int[] nextInta(int n) throws IOException {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        public long[] nextLonga(int n) throws IOException {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }

        public int[][] nextIntm(int n, int m) throws IOException {
            int[][] a = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    a[i][j] = nextInt();
                }
            }
            return a;
        }

        public long[][] nextLongm(int n, int m) throws IOException {
            long[][] a = new long[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    a[i][j] = nextLong();
                }
            }
            return a;
        }

        public BigInteger nextBigInteger() throws IOException {
            return new BigInteger(String.valueOf(next()));
        }
    }
}

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

    public static long factorial(long var1)
    {
        long ans=1;
        while(var1>1)
        {
            ans=ans*var1;
            var1--;
        }
        return ans;
    }
    public static void main(String[] args) throws IOException{

        Reader sc=new Reader();
        PrintWriter out = new PrintWriter(System.out);

//        int t=sc.nextInt();
//
//        while(t-->0)
//        {
           long n=sc.nextLong();
//          r=n/2, ans = nCr * factorial(n/2-1) * factorial(n/2-1);
            long r=n/2;

            long ans=0;
            ans=2*factorial(n-1)/n;

            out.println(ans);

//        }
        out.flush();
    }

    public static void shufflearray(long arr[])
    {

        int n=arr.length;
        Random rand=new Random();
        for(int i=0;i<n;i++)
        {
            long temp=arr[i];
            int randomPos=i+rand.nextInt(n-i);
            arr[i]=arr[randomPos];
            arr[randomPos]=temp;
        }
    }
    //       Arrays.sort(arr, new Comparator<pair>() {
//        //@Override
//        public int compare(pair o1, pair o2) {
//            long l1=o1.a-o2.a;
//            if(l1<0L) return -1;
//            if(l1==0) return 0;
//            return 1;
//        }
//    });
    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String nextLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() throws IOException{
            int c = read();
            while (isSpaceChar(c)) c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }

    }

}

import java.util.Scanner;
import java.math.BigInteger;
// import java.util.Arrays;
// import java.util.PriorityQueue;
// import java.util.Comparator;
// import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        BigInteger n = stdin.nextBigInteger();
        BigInteger two = BigInteger.valueOf(2);
        BigInteger c1 = BigInteger.ONE, c2 = BigInteger.ONE, m = n.divide(two);
        BigInteger fac = BigInteger.ONE;

        for (BigInteger i = BigInteger.ONE; !(i.equals(m.add(BigInteger.ONE))); i = i.add(BigInteger.ONE)) {
            if (!i.equals(m))
                fac = fac.multiply(i);
            c1 = c1.multiply(i);
            BigInteger tmp = i.add(m);
            c2 = c2.multiply(tmp);
        }
        c1 = c1.multiply(two);
        fac = fac.multiply(fac);
        BigInteger ans = (c2.multiply(fac)).divide(c1);
        System.out.println(ans);
        stdin.close();
    }
}

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

public class Codeforces
{
    public static void main(String[] args) throws Exception
    {
        FastReader scn =new FastReader();
        // int t = scn.nextInt();
        // while(t > 0)
        {
            long n = scn.nextLong();

            long val = factorial(n - 1);

            long ans = val/(n/2);
            System.out.println(ans);
            // t--;
        }
    }

    public static long factorial(long n)
    {
        if(n == 0) return 1;
        if(n == 1) return 1;
        if(n == 2) return 2;

        return n * factorial(n - 1);
    }

    public static void print1D(int[] arr)
    {
        for(int ele : arr) System.out.print(ele + " ");
        System.out.println();
    }

    public static void print2D(int[][] matrix)
    {
        for(int[] arr : matrix) print1D(arr);
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

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

import java.util.*;
public class Solution{
	static long M=Long.MAX_VALUE;
     public static void main(String args[])
     {
        Scanner take=new Scanner(System.in);   //
        long n=take.nextLong();
        long ans1=fact(n);
        long ans2=multi(fact(n/2),fact(n/2));
        long ans=(ans1/ans2);
        ans=multi(ans,multi(fact((n/2)-1),fact((n/2)-1)));
        ans=ans/2;
        System.out.println(ans);
     }
     public static long powermod(long b,long p,long m)
     {
         long ans=1;
         while(p!=0)
         {
             if(p%2==1)
             {
                 ans=(((ans%m)*(b%m))%m);
             }
             b=(((b%m)*(b%m))%m);
             p/=2;
         }
         return ans;
     }
     public static long multi(long a,long b)
     {
         return (((a%M)*(b%M))%M);
     }
     public static long fact(long n)
     {
         long i;
         long ans=1;
         for(i=1;i<=n;i++)
         {
             ans=multi(ans,i);
         }
         return ans;
     }
}

import java.util.*;
public class E{
    public static void main(String[] a){
        Scanner s = new Scanner(System.in);
        long n=s.nextInt(),x=2;
        for(int i=1;i<n;i++) x*=i;
        System.out.println(x/n);
}   }

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

	public class Main {
		static FastReader f = new FastReader();
		static PrintWriter out = new PrintWriter(System.out);

		public static void main(String[] args) {
			solve();
			out.close();
		}

		static void solve() {
			long n = f.nextInt();
			long ans = 1;

			for(long i=2;i<=n;i++) {
				ans *= i;
			}

			ans /= n/2;

			out.println(ans/n);

	 	}

		static class FastReader {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			StringTokenizer st;

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

			String nextLine() {
				String s = "";
				try {
					s = br.readLine();
				} catch(IOException ioe) {
					ioe.printStackTrace();
				}

				return s;
			}

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

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

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

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

public class First {

	public static void main(String[] args) throws Exception {

//			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//			int t = Integer.parseInt(br.readLine());
//			StringBuilder sb = new StringBuilder();
//			while (t-- > 0) {
//				int n = Integer.parseInt(br.readLine());
//				String[] str = (br.readLine()).trim().split(" ");
//				int[] arr = new int[n];
//				for (int i = 0; i < n; i++) {
//					arr[i] = Integer.parseInt(str[i]);
//				}
//			}
//			return;

//		first();
//			sec();
//		third();
//		four();
		fif();
//			six();
	}

	private static void first() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			int n = Integer.parseInt(br.readLine());
			int m = n % 10;
			int ans = (m - 1) * 10;
			int d = (n + "").length();

			ans += (d * (d + 1)) / 2;
			System.out.println(ans);

		}
		return;
	}

	private static void sec() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			int n = Integer.parseInt(br.readLine());
			String[] str = (br.readLine()).trim().split(" ");
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = Integer.parseInt(str[i]);
			}
			int right = 0;
			int count = 0;
			int flag = -1;
			int flag1 = -1;
			for (int i = 0; i < n; i++) {
				if (arr[i] == 1) {
					if (flag == -1) {
						count = 0;
						flag = count;

					} else {
						right += count;
						count = 0;
					}
				} else {
					count += 1;
				}
			}
			flag1 = count;

			System.out.println(Math.min(flag, flag1) + right);

		}
		return;
	}

	private static void third() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			int n = Integer.parseInt(br.readLine());
			String[] str = (br.readLine()).trim().split(" ");
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = Integer.parseInt(str[i]);
			}
			boolean flag = false;
			int max = -1;
			int idx = -1;
			for (int i = 0; i < n - 1; i++) {
				if (arr[i] != arr[i + 1]) {
					flag = true;
				}

			}

			if (!flag) {
				System.out.println("-1");
			} else {
				for (int i = 0; i < n; i++) {
					if (i == 0) {
						if (arr[i] > arr[i + 1]) {
							if (arr[i] > max) {
								max = arr[i];
								idx = i + 1;
							}
						}
					} else if (i == n - 1) {
						if (arr[i] > arr[i - 1]) {
							if (arr[i] > max) {
								max = arr[i];
								idx = i + 1;
							}
						}
					} else if (arr[i] > arr[i + 1] || arr[i] > arr[i - 1]) {
						if (arr[i] > max) {
							max = arr[i];
							idx = i + 1;

						}
					}

				}
				System.out.println(idx);
			}
		}
		return;
	}

	private static void four() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());

		while (t-- > 0) {
			int n = Integer.parseInt(br.readLine());
			StringBuilder sb = new StringBuilder();
			String[] str = (br.readLine()).trim().split(" ");
			int[] arr = new int[n];
			HashMap<Integer, Integer> map = new HashMap<>();
			for (int i = 0; i < n; i++) {
				arr[i] = Integer.parseInt(str[i]);
				if (map.containsKey(arr[i])) {
					map.put(arr[i], map.get(arr[i]) + 1);

				} else {
					map.put(arr[i], 1);
				}
			}
			ArrayList<Integer> vtx = new ArrayList<>();
			ArrayList<Integer> ano = new ArrayList<>();
			int minf = 600000, ming = 0;
			for (int i : map.keySet()) {
				if (map.get(i) < minf) {
					minf = map.get(i);
					ming = i;
				}
			}
			for (int i = 0; i < n; i++) {
				if (arr[i] == ming) {
					vtx.add(i + 1);
				} else {
					ano.add(i + 1);
				}
			}
			if (map.size() > 1) {
				sb.append("YES\n");
				int u = vtx.get(0);
				for (int i : ano) {
					sb.append(u + " " + i + "\n");
				}
				int v = ano.get(0);
				for (int i = 1; i < vtx.size(); i++) {
					sb.append(v + " " + vtx.get(i) + "\n");
				}

			} else {
				sb.append("NO\n");
			}
			System.out.print(sb);
		}
		return;
	}

	private static void fif() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		long n = Integer.parseInt(br.readLine());
		long ans = 0;

		ans = factorial((n/2)-1);
		long p = n-1;
		for(int i =1;i<n/2;i++) {
			ans*=p;
			p-=1;
		}
		System.out.println(ans);
		return;

	}

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

	private static void six() throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int t = Integer.parseInt(br.readLine());
		StringBuilder sb = new StringBuilder();

		while (t-- > 0) {
			int n = Integer.parseInt(br.readLine());
			String[] str = (br.readLine()).trim().split(" ");
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = Integer.parseInt(str[i]);
			}
		}
		return;
	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s = new Scanner(System.in);
		long n = s.nextLong();
		long temp = 1;
		for(int i = 1;i <= n;i++) temp *= i;
		n *= n;
		n /= 2;
		n *= 2;
		System.out.println((2 * temp) / (n));

	}

}

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

public class TwoRounDances {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int nn = sc.nextInt();
        System.out.println(Calculate(nn));
    }

    private static BigInteger Calculate(int nn) {
        BigInteger bi = new BigInteger(""+(nn-1));
        bi = fact(bi);
        bi = bi.divide(new BigInteger(""+(nn)).divide(new BigInteger("2")));

        return bi;
    }

    private static BigInteger fact(BigInteger bi) {
        if (Integer.valueOf(String.valueOf(bi))<=1){
            return bi;
        }
        return bi.multiply(fact(bi.subtract(BigInteger.valueOf(1))));
    }

}

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

public class E {
    public static void main(String args[]) {
        Scanner cin = new Scanner(System.in);
        int n=cin.nextInt();
        if (n == 2) {
            System.out.println(1);
        }
        else {
            BigInteger sum = new BigInteger("1");
            for (int i = (n / 2 + 1); i <= n; ++i) {
                sum = sum.multiply(BigInteger.valueOf(i));
            }
            for (int i = 1; i <= n / 2; ++i) {
                sum = sum.divide(BigInteger.valueOf(i));
            }
            for (int i = 1; i <= n / 2 - 1; ++i) {
                sum = sum.multiply(BigInteger.valueOf(i * i));
            }
            System.out.println(sum.divide(BigInteger.valueOf(2)));
        }
    }
}

import java.util.Scanner;

public class E {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		if(n==2) {
			System.out.println(1);
		}
		else {
			long ans = n;
			for(int i = n-1; i>n/2; i--) {
				ans*=i;
			}
			for(int i = n/2; i>0; i--) {
				ans/=i;
			}
			ans/=2;
			long circularP= n/2-1;
			for(int i= n/2-2; i>0; i--) {
				circularP *=i;
			}
			ans= ans*circularP*circularP;
			System.out.println(ans);
		}
	}

}

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

public class Factorial
{
	static long fact[];

	public static void main(String [] args) throws IOException
	{
		BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(buf.readLine().trim());
		factorial(20);
		long sol = ((fact[n]/(fact[n/2]*fact[n/2]))/2)*(fact[n/2-1]*fact[n/2-1]);
		System.out.println(sol);

	}
/*	public static int findSol(String str,int a,int b)
	{

	}*/
	public static void factorial(int n)
	{
		fact = new long[n+1];
		fact[0] = 1;
		for(int i=1;i<=n;i++)
			fact[i] = i*fact[i-1];
	}
}

import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.DataInputStream;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.util.InputMismatchException;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	static class TaskAdapter implements Runnable {
		@Override
		public void run() {
			long startTime = System.currentTimeMillis();
			InputStream inputStream = System.in;
			OutputStream outputStream = System.out;
			FastReader in = new FastReader(inputStream);
			Output out = new Output(outputStream);
			ETwoRoundDances solver = new ETwoRoundDances();
			solver.solve(1, in, out);
			out.close();
			System.err.println(System.currentTimeMillis()-startTime+"ms");
		}
	}

	public static void main(String[] args) throws Exception {
		Thread thread = new Thread(null, new TaskAdapter(), "", 1<<28);
		thread.start();
		thread.join();
	}

	static class ETwoRoundDances {
		public ETwoRoundDances() {
		}

		public void solve(int kase, InputReader in, Output pw) {
			int n = in.nextInt();
			BigInteger ans = BigInteger.ONE;
			for(int i = 0; i<n >> 1; i++) {
				ans = ans.multiply(BigInteger.valueOf(n-i));
			}
			for(int i = 1; i<=n-1 >> 1; i++) {
				ans = ans.multiply(BigInteger.valueOf(i));
			}
			pw.println(ans.divide(BigInteger.valueOf(n >> 1)).divide(BigInteger.TWO));
		}

	}

	static class FastReader implements InputReader {
		final private int BUFFER_SIZE = 1<<16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer;
		private int bytesRead;

		public FastReader(InputStream is) {
			din = new DataInputStream(is);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public int nextInt() {
			int ret = 0;
			byte c = skipToDigit();
			boolean neg = (c=='-');
			if(neg) {
				c = read();
			}
			do {
				ret = ret*10+c-'0';
			} while((c = read())>='0'&&c<='9');
			if(neg) {
				return -ret;
			}
			return ret;
		}

		private boolean isDigit(byte b) {
			return b>='0'&&b<='9';
		}

		private byte skipToDigit() {
			byte ret;
			while(!isDigit(ret = read())&&ret!='-') ;
			return ret;
		}

		private void fillBuffer() {
			try {
				bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			}catch(IOException e) {
				e.printStackTrace();
				throw new InputMismatchException();
			}
			if(bytesRead==-1) {
				buffer[0] = -1;
			}
		}

		private byte read() {
			if(bytesRead==-1) {
				throw new InputMismatchException();
			}else if(bufferPointer==bytesRead) {
				fillBuffer();
			}
			return buffer[bufferPointer++];
		}

	}

	static interface InputReader {
		int nextInt();

	}

	static class Output implements Closeable, Flushable {
		public StringBuilder sb;
		public OutputStream os;
		public int BUFFER_SIZE;
		public String lineSeparator;

		public Output(OutputStream os) {
			this(os, 1<<16);
		}

		public Output(OutputStream os, int bs) {
			BUFFER_SIZE = bs;
			sb = new StringBuilder(BUFFER_SIZE);
			this.os = new BufferedOutputStream(os, 1<<17);
			lineSeparator = System.lineSeparator();
		}

		public void print(String s) {
			sb.append(s);
			if(sb.length()>BUFFER_SIZE >> 1) {
				flushToBuffer();
			}
		}

		public void println(Object... o) {
			for(int i = 0; i<o.length; i++) {
				if(i!=0) {
					print(" ");
				}
				print(String.valueOf(o[i]));
			}
			println();
		}

		public void println() {
			sb.append(lineSeparator);
		}

		private void flushToBuffer() {
			try {
				os.write(sb.toString().getBytes());
			}catch(IOException e) {
				e.printStackTrace();
			}
			sb = new StringBuilder(BUFFER_SIZE);
		}

		public void flush() {
			try {
				flushToBuffer();
				os.flush();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

		public void close() {
			flush();
			try {
				os.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

	}
}

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
	static int a[] = new int[5000 + 5];
	static long ans[] = new long[50], dp[] = new long[50];
	static long C[][] = new long[50][50];
	public static void main(String[] args) {
		for(int i = 1; i <= 20; ++ i) {
			for(int j = 0; j <= 10 && j <= i; ++ j)
			{
				if(j == 0) {
					C[i][j] = 1;
				}
				else C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
			}
		}
		dp[2] = 1;
		dp[1] = 1;
		for(int i = 3; i <= 10; ++ i) {
			dp[i] = dp[i - 1] * (i - 1);
		}
		for(int i = 2; i <= 20; i += 2) {
			ans[i] = dp[i / 2] * dp[i / 2] * C[i][ i / 2];
		}
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		System.out.println(ans[n]);
	}

}

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

public class Main {
    public static long fact(long n) {
        if(n == 1) return 1;
        return n * fact(n - 1);
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long res = 1;
        res = (long)(fact(n)/(Math.pow(n/2, 2) * 2));
        System.out.println(res);
    }
}

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

public class E{
	static int [][]dp = new int[1001][1001];

	public static void main(String[] args)  throws IOException,NumberFormatException{
		try {
		FastScanner sc=new FastScanner();
		int n=sc.nextInt();
		long ans=1;
		for(int i=n-1;i>=2;i--) {
			ans*=i;
		}
		System.out.println(ans/(n/2));
		}
		catch(Exception e) {
			return ;
		}

	}

	static final Random random=new Random();

	static void ruffleSort(int[] a) {
		int n=a.length;
		for(int i=0;i<n;i++) {
			int oi=random.nextInt(n),temp=a[oi];
			a[oi]=a[i]; a[i]=temp;
		}
		Arrays.sort(a);
	}

	public static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
                                      st=new StringTokenizer(br.readLine());
                              } catch (IOException e) {}
			return st.nextToken();
		}

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

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

		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}

		long[] readLongArray(int n) {
			long[] a=new long[n];
			for(int i=0; i<n ; i++) a[i]=nextLong();
			return a;
		}

		String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
	}

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Main {
	static int[][] cache;

	static int comb(int n, int r) {
		if (r == 0 || n == r) {return 1;}
		if (cache[n][r] != 0) {return cache[n][r];}
		return cache[n][r] = (comb(n - 1, r - 1) + comb(n - 1, r));
	}

	static long fac(int N) {
		if (N == 0) {return 1;}
		return N * fac(N - 1);
	}

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		int N = Integer.parseInt(br.readLine());
		cache = new int[N + 1][N + 1];
		long ret = comb(N, N / 2) * ((long)Math.pow(fac(N / 2 - 1), 2)) / 2;
		bw.write(String.valueOf(ret));
		bw.newLine();
		bw.close();
	}

}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class MarketingScheme {
    public static void main(String[] args) throws IOException {
        // InputStream inputStream = new FileInputStream("input.txt");
        // OutputStream outputStream = new FileOutputStream("output.txt");
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        long mod = (long)(1e9) + 7;
        long fact[];
        int depth[];
        int parentTable[][];
        int degree[];
        ArrayList<Integer> leaves;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        int diam = 0;

        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            while(testNumber-->0){
                int n = in.nextInt();
                fact = new long[n+1];
                fact[0] = 1;
                for(int i=1;i<=n;i++)
                    fact[i] = fact[i-1]*i;
                out.println(fact[n] / pow(fact[n/2] , 2) / 2 * pow(fact[n/2-1] , 2));
            }
        }

        public int lower(ArrayList<Integer> a , int x){
            if(a.size() == 0)
                return 0;
            if(a.get(a.size()-1) < x)
                return a.size();
            int l = 0;
            int r = a.size()-1;
            while(l<=r){
                int mid = (l+r)>>1;
                if(a.get(mid)>=x && (mid<1 || a.get(mid-1)<x))
                    return mid;
                else if(a.get(mid) < x)
                    l = mid+1;
                else
                    r = mid-1;
            }
            return -1;
        }

        public Node left(Node x){
            if(x == null || x.empty)
                return x;
            Node y = left(x.left);
            x.left = y;
            return y;
        }

        public Node right(Node x){
            if(x == null || x.empty)
                return x;
            Node y = right(x.right);
            x.right = y;
            return y;
        }

        class Node{
            int val;
            Node left;
            Node right;
            boolean empty;
            public Node(int val){
                this.val = val;
                left = null;
                right = null;
                empty = true;
            }
        }

        public Node add(int a[] , int start , int end){
            if(start>end)
                return null;
            int mid = (start+end)>>1;
            Node root = new Node(a[mid]);
            root.left = add(a , start , mid-1);
            root.right = add(a ,mid+1 , end);
            return root;
        }

        public void dfs(ArrayList<ArrayList<int[]>> a , int index , int parent , int val , int visited[]){
            if(index == a.size()-1){
                max = Math.max(max , val);
                return;
            }
            visited[index] = 1;
            for(int i=0;i<a.get(index).size();i++){
                int u = index;
                int v = a.get(index).get(i)[0];
                int speed = a.get(index).get(i)[1];
                if(visited[v] == 1){
                    if(v == a.size()-1){
                        max = Math.max(max , Math.min(speed , val));
                    }
                    continue;
                }
                dfs(a , v , u , Math.min(val , speed) , visited);
            }
        }

        class Pair{
            int u;
            int v;
            int speed;
            public Pair(int u , int v , int speed){
                this.u = u;
                this.v = v;
                this.speed = speed;
            }
        }

        public void add(HashMap<Integer , ArrayList<Integer>> m , int x , int y){
            if(!m.containsKey(x))
                m.put(x , new ArrayList<>());
            ArrayList<Integer> a = m.get(x);
            a.add(y);
        }

        public void dfs(ArrayList<ArrayList<Integer>> a , int index , int parent , int size[]){
            size[index] = 1;
            depth[index] = 1+depth[parent];
            for(int i=0;i<a.get(index).size();i++){
                if(a.get(index).get(i) == parent)
                    continue;
                dfs(a , a.get(index).get(i) , index , size);
                size[index] += size[a.get(index).get(i)];
            }
        }

        public int distance(ArrayList<ArrayList<Integer>> a , int u , int v){
            return depth[u]+depth[v] - 2*depth[lca(a , u , v)];
        }

        public int lca(ArrayList<ArrayList<Integer>> a , int u , int v){
            if(depth[v]<depth[u]){
                int x = u;
                u = v;
                v = x;
            }
            int diff = depth[v] - depth[u];
            for(int i=0;i<parentTable[v].length;i++){
                // checking whether the ith bit is set in the diff variable
                if(((diff>>i)&1) == 1)
                    v = parentTable[v][i];
            }
            if(v == u)
                return v;
            for(int i=parentTable[v].length-1;i>=0;i--){
                if(parentTable[u][i] != parentTable[v][i]){
                    v = parentTable[v][i];
                    u = parentTable[u][i];
                }
            }
            return parentTable[u][0];
        }

        public int[][] multiply(int a[][] , int b[][]){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++)
                        c[i][j] += a[i][k]*b[k][j];
                }
            }
            return c;
        }

        public int[][] multiply(int a[][] , int b[][] , int mod){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++){
                        c[i][j] += a[i][k]*b[k][j];
                        c[i][j]%=mod;
                    }
                }
            }
            return c;
        }

        public int[][] pow(int a[][] , long b){
            int res[][] = new int[a.length][a[0].length];
            for(int i=0;i<a.length;i++)
                res[i][i] = 1;
            while(b>0){
                if((b&1) == 1)
                    res = multiply(res , a , 10);
                a = multiply(a , a , 10);
                b>>=1;
            }
            return res;
        }

        // for the min max problems
        public void build(int lookup[][] , int arr[], int n) {
            for (int i = 0; i < n; i++)
                lookup[i][0] = arr[i];
            for (int j = 1; (1 << j) <= n; j++) {
                for (int i = 0; (i + (1 << j) - 1) < n; i++) {
                    if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1])
                        lookup[i][j] = lookup[i][j - 1];
                    else
                        lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1];
                }
            }
        }
        public int query(int lookup[][] , int L, int R) {
            int j = (int)(Math.log(R - L + 1)/Math.log(2));
            if (lookup[L][j] >= lookup[R - (1 << j) + 1][j])
                return lookup[L][j];
            else
                return lookup[R - (1 << j) + 1][j];
        }

        // for printing purposes
        public void print1d(int a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print1d(long a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print2d(int a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }
        public void print2d(long a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }

        public void sieve(int a[]){
            a[0] = a[1] = 1;
            int i;
            for(i=2;i*i<=a.length;i++){
                if(a[i] != 0)
                    continue;
                a[i] = i;
                for(int k = (i)*(i);k<a.length;k+=i){
                    if(a[k] != 0)
                        continue;
                    a[k] = i;
                }
            }
        }

        public long nCrPFermet(int n , int r , long p){
            if(r==0)
                return 1l;
            // long fact[] = new long[n+1];
            // fact[0] = 1;
            // for(int i=1;i<=n;i++)
            //     fact[i] = (i*fact[i-1])%p;
            long modInverseR = pow(fact[r] , p-2 , p);
            long modInverseNR = pow(fact[n-r] , p-2 , p);
            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
            return w;
        }
        public long pow(long a, long b, long m) {
            a %= m;
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a % m;
                a = a * a % m;
                b >>= 1;
            }
            return res;
        }
        public long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a;
                a = a * a;
                b >>= 1;
            }
            return res;
        }
        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) {
            if (start > end) {
                return;
            }
            int mid = (start + end) / 2;
            a.add(mid);
            sortedArrayToBST(a, start, mid - 1);
            sortedArrayToBST(a, mid + 1, end);
        }
        class Combine{
            int value;
            int delete;
            Combine(int val , int delete){
                this.value = val;
                this.delete = delete;
            }
        }
        class Sort2 implements Comparator<Combine>{
            public int compare(Combine a , Combine b){
                if(a.value > b.value)
                    return 1;
                else if(a.value == b.value && a.delete>b.delete)
                    return 1;
                else if(a.value == b.value && a.delete == b.delete)
                    return 0;
                return -1;
            }
        }
        public int lowerLastBound(ArrayList<Integer> a , int x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>=x)
                return -1;
            if(a.get(r)<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid-1)<x)
                    return mid-1;
                else if(a.get(mid)>=x)
                    r = mid-1;
                else if(a.get(mid)<x && a.get(mid+1)>=x)
                    return mid;
                else if(a.get(mid)<x && a.get(mid+1)<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(ArrayList<Integer> a , int x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>x)
                return l;
            if(a.get(r)<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid+1)>x)
                    return mid+1;
                else if(a.get(mid)<=x)
                    l = mid+1;
                else if(a.get(mid)>x && a.get(mid-1)<=x)
                    return mid;
                else if(a.get(mid)>x && a.get(mid-1)>x)
                    r = mid-1;
            }
            return mid;
        }
        public int lowerLastBound(long a[] , long x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>=x)
                return -1;
            if(a[r]<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid-1]<x)
                    return mid-1;
                else if(a[mid]>=x)
                    r = mid-1;
                else if(a[mid]<x && a[mid+1]>=x)
                    return mid;
                else if(a[mid]<x && a[mid+1]<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(long a[] , long x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>x)
                return l;
            if(a[r]<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid+1]>x)
                    return mid+1;
                else if(a[mid]<=x)
                    l = mid+1;
                else if(a[mid]>x && a[mid-1]<=x)
                    return mid;
                else if(a[mid]>x && a[mid-1]>x)
                    r = mid-1;
            }
            return mid;
        }
        public long log(float number , int base){
            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
        }
        public long gcd(long a , long b){
            if(a<b){
                long c = b;
                b = a;
                a = c;
            }
            while(b!=0){
                long c = a;
                a = b;
                b = c%a;
            }
            return a;
        }
        public long[] gcdEx(long p, long q) {
            if (q == 0)
                return new long[] { p, 1, 0 };
            long[] vals = gcdEx(q, p % q);
            long d = vals[0];
            long a = vals[2];
            long b = vals[1] - (p / q) * vals[2];
            // 0->gcd 1->xValue 2->yValue
            return new long[] { d, a, b };
        }
        public void sievePhi(int a[]){
            a[0] = 0;
            a[1] = 1;
            for(int i=2;i<a.length;i++)
                a[i] = i-1;
            for(int i=2;i<a.length;i++)
                for(int j = 2*i;j<a.length;j+=i)
                    a[j] -= a[i];
        }
        public void lcmSum(long a[]){
            int sievePhi[] = new int[(int)1e6 + 1];
            sievePhi(sievePhi);
            a[0] = 0;
            for(int i=1;i<a.length;i++)
                for(int j = i;j<a.length;j+=i)
                    a[j] += (long)i*sievePhi[i];
        }
    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            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());
        }

    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {

	//static int [] arr;
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        //int t = sc.nextInt();
        int t = 1;
        long [] fact = new long [21];
        fact[0] = 1;
        for(int i = 1 ; i < 21 ; i++) fact[i] = (long) i*fact[i-1];

        while (t-->0) {
        	int n = sc.nextInt();
        	long ans = fact[n];
        	ans/= fact[n>>1];
        	ans/= fact[n>>1];
        	ans = (ans * fact[(n>>1)-1] * fact[(n>>1)-1])>>1;
        	out.println(ans);
        }
        out.close();
    }

}

	 class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String file) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(file));
		}

		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 int[] nextIntArr(int length) throws IOException{
			int[] arr = new int[length];
			for(int i = 0 ; i < length ; i++)
				arr[i] = Integer.parseInt(next());
			return arr;
		}
		public boolean ready() throws IOException {
			return br.ready();
		}
	 }

import java.util.Scanner;

public class TwoRoundDances {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
	       long f[]=new long[21];
	        f[0]=1;
	        for(int i=1;i<=n;i++)
	        {
	            f[i]=f[i-1]*i;
	        }
	        long ans=f[n]/f[n/2];
	        ans=ans/f[n/2];
	        ans=ans*f[n/2-1];
	        ans=ans*f[n/2-1];
	        ans=ans/2;
	        System.out.println(ans);
	}

}

//package com.company;
import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int n = Integer.parseInt(br.readLine());
        long ans = 1;
        for(int i=1;i<n;i++) ans*=i;
        pw.println(2*ans/n);
        pw.flush();
        pw.close();
    }
}

// package programs;

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

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class Main
{

	static int mod = 1000000007;
	static int MOD = 1000000007;
	static final long M = (int)1e9+7;

	static class Pair implements Comparable<Pair> {
		int first, second;
		public Pair(int first, int second) {
			this.first=first;
			this.second=second;
		}

		public int compareTo(Pair o) {
			return Integer.compare(o.second, second);
		}
	}

	static class Reader
	{
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public Reader()
		{
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public Reader(String file_name) throws IOException
		{
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String next() throws IOException
		{
			byte[] buf = new byte[64]; // line length
			int cnt = 0, c;
			while ((c = read()) != -1)
			{
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public int nextInt() throws IOException
		{
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
			{
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}
		int[] readArray(int n) throws IOException {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}

		public long nextLong() throws IOException
		{
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public double nextDouble() throws IOException
		{
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');

			if (c == '.')
			{
				while ((c = read()) >= '0' && c <= '9')
				{
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		private void fillBuffer() throws IOException
		{
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() throws IOException
		{
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException
		{
			if (din == null)
				return;
			din.close();
		}

	}

	public static boolean isPrime(int n) {
		if(n == 1)
		{
			return false;
		}
		for(int i = 2;i*i<=n;i++)
		{
			if(n%i == 0)
			{
				return false;
			}
		}
		return true;
	}

	public static int gcd(int a, int b)
	{
		if(b == 0)
		 return a;

		else
		return gcd(b,a%b);
	}

	public static int[] computePrefix(int arr[], int n)
	{
		int[] prefix = new int[n];
		prefix[0] = arr[0];
		for(int i = 1;i<n;i++)
		{
			prefix[i] = prefix[i-1]+arr[i];
		}

		return prefix;
	}

	public static int lcm(int a, int b)
	{
		return (a*b)/gcd(a,b);
	}

	public static int phi(int n)  //euler totient function
    {
        int result = 1;
        for (int i = 2; i < n; i++)
            if (gcd(i, n) == 1)
                result++;
        return result;
    }

	public static int fastPow(int x, int n) //include mod at each step if asked and in args of fn too
	{
		if(n == 0)
			return 1;
		else if(n%2 == 0)
			return fastPow(x*x,n/2);
		else
			return x*fastPow(x*x,(n-1)/2);
	}

	static int LowerBound(int a[], int x) {
		  int l=-1,r=a.length;
		  while(l+1<r) {
		    int m=(l+r)>>>1;
		    if(a[m]>=x) r=m;
		    else l=m;
		  }
		  return r;
		}

	public static int[] radixSort(int[] f){ return radixSort(f, f.length); }
	public static int[] radixSort(int[] f, int n)
	{
		int[] to = new int[n];
		{
			int[] b = new int[65537];
			for(int i = 0;i < n;i++)b[1+(f[i]&0xffff)]++;
			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
			for(int i = 0;i < n;i++)to[b[f[i]&0xffff]++] = f[i];
			int[] d = f; f = to;to = d;
		}
		{
			int[] b = new int[65537];
			for(int i = 0;i < n;i++)b[1+(f[i]>>>16)]++;
			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
			for(int i = 0;i < n;i++)to[b[f[i]>>>16]++] = f[i];
			int[] d = f; f = to;to = d;
		}
		return f;
	}

	static int UpperBound(int a[], int x) {
	    int l=-1,r=a.length;
	    while(l+1<r) {
	       int m=(l+r)>>>1;
	       if(a[m]<=x) l=m;
	       else r=m;
	    }
	    return l+1;
	 }

	public static void main(String[] args) throws IOException
	{
		Reader sc = new Reader();

			long n = sc.nextLong();
			n /= 2;
			long ans = 1;
			for(int i = 0;i<2*n;i++)
			{
				ans *= (i+1);
			}

			ans = ans/(2*n*n);

			System.out.println(ans);

	}
}

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.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;

public class E {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int n=sc.nextInt();
		long ans=0;

		long ar[]= {
				1, 3, 40, 1260, 72576, 6652800, 889574400, 163459296000l, 39520825344000l, 12164510040883200l
		};

		System.out.println(ar[(n/2)-1]);

	}

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

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

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

		int[] readArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		long[] readLongArray(int n) {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}

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

}

import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{
       static long factorial(int n)
    {
        long res = 1, i;
        for (i=2; i<=n; i++)
            res *= i;
        return res;
    }
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
	//	BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
		Reader sc=new Reader();
		PrintWriter out=new PrintWriter(System.out);
		//int t=Integer.parseInt(sc.readLine());
		int n=sc.nextInt();
		out.println(factorial(n-1)/((n*1l)/2l));
		out.flush();
	}
}class Reader
	{
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public Reader()
		{
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public Reader(String file_name) throws IOException
		{
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException
		{
			byte[] buf = new byte[(int)1e8]; // line length
			int cnt = 0, c;
			while ((c = read()) != -1)
			{
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public int nextInt() throws IOException
		{
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
			{
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public long nextLong() throws IOException
		{
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public double nextDouble() throws IOException
		{
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');

			if (c == '.')
			{
				while ((c = read()) >= '0' && c <= '9')
				{
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		private void fillBuffer() throws IOException
		{
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() throws IOException
		{
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException
		{
			if (din == null)
				return;
			din.close();
		}
	}

import java.util.Scanner;

public class E_Round_Dances {

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

			int n = sc.nextInt();
			long fact[]=new long[21];
		fact[0]=1;
		// finding factorial
		for(int i=1;i<21;i++)
			fact[i]=fact[i-1]*i;

		long ans=(fact[n]/fact[n/2])/fact[n/2]; // nCn/2 (combination)
		ans=ans*fact[n/2-1]*fact[n/2-1];
		System.out.println(ans/2);
		}

	}

import java.util.*;
public class E{
    public static void main(String[] a){
        Scanner s = new Scanner(System.in);
        long n=s.nextInt(),x=2;
        for(int i=1;i<n;i++) x*=i;
        System.out.println(x/n);
}   }

//package codeforces.problem.oct;

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

/*
https://codeforces.com/problemset/problem/1433/E

 */
public class TaskE_1433 {
    static long fact(long n) {
        if (n == 0 || n == 1) return 1L;
        long r = 1;
        for (int i = 1; i <= n; i++) {
            r *= i;
        }
        return r;
    }

    static void solve() {
        int n = FS.nextInt();
        FS.pt.println((fact(n) / (((n * n) / 2))));
    }

    public static void main(String[] args) {
//        int T = FS.nextInt();
//        for (int tt = 0; tt < T; tt++) {
        solve();
//        }
        FS.pt.close();
    }

    static class FS {
        private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        private static StringTokenizer st = new StringTokenizer("");
        static PrintWriter pt = new PrintWriter(System.out);

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

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

        static int[] readArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        static int[][] read2Array(int m, int n) {
            int[][] a = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    a[i][j] = nextInt();
                }
            }
            return a;
        }

        static long[][] read2ArrayL(int m, int n) {
            long[][] a = new long[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    a[i][j] = nextInt();
                }
            }
            return a;
        }

        void printArr(long[] arr) {
            for (long value : arr) {
                pt.print(value);
                pt.print(" ");
            }
            pt.println();
        }

        static long[] readArrayL(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        static void printArr(int[] arr) {
            for (int value : arr) {
                pt.print(value);
                pt.print(" ");
            }
            pt.println();
        }

        static void printArrL(int[] arr) {
            for (int value : arr) {
                pt.print(value);
                pt.print(" ");
            }
            pt.println();
        }

        static void print2Arr(int[][] arr, int m, int n) {
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    pt.print(arr[i][j]);
                    pt.print(" ");
                }
                pt.println();
            }
            pt.println();
        }

        static void print2Arr(long[][] arr, int m, int n) {
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    pt.print(arr[i][j]);
                    pt.print(" ");
                }
                pt.println();
            }
            pt.println();
        }

        static List<Long> readListLong(int n) {
            List<Long> list = new ArrayList<>(n);
            for (int i = 0; i < n; i++) {
                list.add(nextLong());
            }
            return list;
        }

        static List<Integer> readListInt(int n) {
            List<Integer> list = new ArrayList<>(n);
            for (int i = 0; i < n; i++) {
                list.add(nextInt());
            }
            return list;
        }

        static <T> void printList(List<T> list) {
            for (T value : list) {
                pt.print(value);
                pt.print(" ");
            }
            pt.println();
        }

        static void close() {
            pt.close();
        }

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

import java.util.*;
import java.io.*;
public class Main {
    public static void main(String args[]) {

      Scanner sc = new Scanner(System.in);
      PrintWriter w = new PrintWriter(System.out);

      int n = sc.nextInt();
      long fact[] = new long[21];
      fact[0] = 1;
      for(int i = 1; i <= 20; i++)
      {
          fact[i] = fact[i-1]*(long)i;
      }
      long part1 = fact[n]/(fact[n/2]*fact[n/2]);
      long part2 = fact[(n/2) - 1] * fact[(n/2) - 1];
      long ans = (part1*part2)/2;
      w.println(ans);
      w.close();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {

    public static long factorial(int n){
        long arr[] = new long[21];
        arr[0] = 1;
        arr[1] = 1;
        for(int i=2;i<=20;i++){
            arr[i] = arr[i-1]*i;
        }
        return arr[n];
    }

    public static long nCr(int n, int r){
        long ans = factorial(n)/factorial(r);
        return ans/factorial(n-r);
    }

    public static void main(String[] args){
        MyScanner sc = new MyScanner();
        int n = sc.nextInt();
        long first = nCr(n,n/2);
        long second = factorial(n/2 - 1);
        second = second*second;
        second = second*first;
        second = second/2;
        System.out.println(second);
    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

    }

}

import java.util.Scanner;

public class E {
    public static long factorial(int n) {
        long result = 1;

        for (int i = 2; i <= n; i++) {
            result *= i;
        }

        return result;
    }

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

        long result = factorial(n);
        double dem = (Math.pow(n / 2, 2) * 2);
        System.out.println(result / (long)dem);

    }
}

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

public class Problem_E {
	public static void main(String[] args) {
		InputReader in = new InputReader();

		int N = in.nextInt();
		long x = 1;
		for (int i = 0; i < N / 2; i++) {
			x *= N - i;
		}
		for (int i = 1; i < N / 2; i++) {
			x *= i;
		}
		x /= N / 2;
		x /= 2;

		System.out.println(x);
	}

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

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in));
		}

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

		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return null;
		}

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

import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{
    static long fact(long n){
        long res=1;
        for(int i=1;i<=n;i++){
            res=res*i;
        }
        return res;
    }
	public static void main (String[] args) throws java.lang.Exception
	{
	    Scanner sc=new Scanner(System.in);
	   // BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	    int t=1;
	    //t=sc.nextInt();
	  //  int t=Integer.parseInt(br.readLine());
	    while(--t>=0){
	        long n=sc.nextLong();
	        long D=fact(n/2)*fact(n/2);
	        long temp=(fact(n)/D)/2;
	        //System.out.println(temp);
	        long temp1=(fact(n/2-1));
	       System.out.println(temp*temp1*temp1);

	    }

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Objects;
import java.util.StringTokenizer;
import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {

    static BiFunction<Integer, Integer, Integer> ADD = (x, y) -> (x + y);
    static BiFunction<ArrayList<Integer>, ArrayList<Integer>, ArrayList<Integer>> ADD_ARRAY_LIST = (x, y) -> {
        x.addAll(y);
        return x;
    };

    static Function<Pair<Integer, Integer>, Integer> GET_FIRST = (x) -> (x.first);
    static Function<Pair<Integer, Integer>, Integer> GET_SECOND = (x) -> (x.second);
    static Comparator<Pair<Integer, Integer>> C = Comparator.comparing(GET_FIRST).thenComparing(GET_SECOND);

    public static void main(String[] args) throws Exception {
        long startTime = System.nanoTime();
        int t = 1;
        while (t-- > 0) {
            solve();
        }
        long endTime = System.nanoTime();
        err.println("Execution Time : +" + (endTime - startTime) / 1000000 + " ms");
        exit(0);
    }

    static void solve() {
        int n = in.nextInt();
        long ans = 1;
        for (int i = n - 1, j = 1; j < n / 2; j++, i--) {
            ans *= i;
        }
        for (int i = n / 2 - 1; i >= 1; i--) {
            ans *= i;
        }
        out.println(ans);
    }

    static void debug(Object... args) {
        for (Object a : args) {
            out.println(a);
        }
    }

    static void y() {
        out.println("YES");
    }

    static void n() {
        out.println("NO");
    }

    static <T> T min(T a, T b, Comparator<T> C) {
        if (C.compare(a, b) <= 0) {
            return a;
        }
        return b;
    }

    static <T> T max(T a, T b, Comparator<T> C) {
        if (C.compare(a, b) >= 0) {
            return a;
        }
        return b;
    }

    static void fail() {
        out.println("-1");
    }

    static class Pair<T, R> {
        public T first;
        public R second;

        public Pair(T first, R second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public boolean equals(final Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            final Pair<?, ?> pair = (Pair<?, ?>) o;
            return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
        }

        @Override
        public int hashCode() {
            return Objects.hash(first, second);
        }

        @Override
        public String toString() {
            return "Pair{" + "a=" + first + ", b=" + second + '}';
        }

        public T getFirst() {
            return first;
        }

        public R getSecond() {
            return second;
        }
    }

    static <T, R> Pair<T, R> make_pair(T a, R b) {
        return new Pair<>(a, b);
    }

    static class ArrayUtils {

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

        static void swap(char[] a, int i, int j) {
            char temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }

        static void print(char[] a) {
            for (char c : a) {
                out.print(c);
            }
            out.println("");
        }

        static int[] reverse(int[] data) {
            int[] p = new int[data.length];
            for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
                p[i] = data[j];
            }
            return p;
        }

        static void prefixSum(long[] data) {
            for (int i = 1; i < data.length; i++) {
                data[i] += data[i - 1];
            }
        }

        static void prefixSum(int[] data) {
            for (int i = 1; i < data.length; i++) {
                data[i] += data[i - 1];
            }
        }

        static long[] reverse(long[] data) {
            long[] p = new long[data.length];
            for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
                p[i] = data[j];
            }
            return p;
        }

        static char[] reverse(char[] data) {
            char[] p = new char[data.length];
            for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
                p[i] = data[j];
            }
            return p;
        }

        static int[] MergeSort(int[] A) {
            if (A.length > 1) {
                int q = A.length / 2;
                int[] left = new int[q];
                int[] right = new int[A.length - q];
                System.arraycopy(A, 0, left, 0, q);
                System.arraycopy(A, q, right, 0, A.length - q);
                int[] left_sorted = MergeSort(left);
                int[] right_sorted = MergeSort(right);
                return Merge(left_sorted, right_sorted);
            } else {
                return A;
            }
        }

        static int[] Merge(int[] left, int[] right) {
            int[] A = new int[left.length + right.length];
            int i = 0;
            int j = 0;
            for (int k = 0; k < A.length; k++) {
                // To handle left becoming empty
                if (i == left.length && j < right.length) {
                    A[k] = right[j];
                    j++;
                    continue;
                }
                // To handle right becoming empty
                if (j == right.length && i < left.length) {
                    A[k] = left[i];
                    i++;
                    continue;
                }
                if (left[i] <= right[j]) {
                    A[k] = left[i];
                    i++;
                } else {
                    A[k] = right[j];
                    j++;
                }
            }
            return A;
        }

        static long[] MergeSort(long[] A) {
            if (A.length > 1) {
                int q = A.length / 2;
                long[] left = new long[q];
                long[] right = new long[A.length - q];
                System.arraycopy(A, 0, left, 0, q);
                System.arraycopy(A, q, right, 0, A.length - q);
                long[] left_sorted = MergeSort(left);
                long[] right_sorted = MergeSort(right);
                return Merge(left_sorted, right_sorted);
            } else {
                return A;
            }
        }

        static long[] Merge(long[] left, long[] right) {
            long[] A = new long[left.length + right.length];
            int i = 0;
            int j = 0;
            for (int k = 0; k < A.length; k++) {
                // To handle left becoming empty
                if (i == left.length && j < right.length) {
                    A[k] = right[j];
                    j++;
                    continue;
                }
                // To handle right becoming empty
                if (j == right.length && i < left.length) {
                    A[k] = left[i];
                    i++;
                    continue;
                }
                if (left[i] <= right[j]) {
                    A[k] = left[i];
                    i++;
                } else {
                    A[k] = right[j];
                    j++;
                }
            }
            return A;
        }
    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 2048);
            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());
        }

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

        public int[] readAllInts(int n) {
            int[] p = new int[n];
            for (int i = 0; i < n; i++) {
                p[i] = in.nextInt();
            }
            return p;
        }

        public int[] readAllInts(int n, int s) {
            int[] p = new int[n + s];
            for (int i = s; i < n + s; i++) {
                p[i] = in.nextInt();
            }
            return p;
        }

        public long[] readAllLongs(int n) {
            long[] p = new long[n];
            for (int i = 0; i < n; i++) {
                p[i] = in.nextLong();
            }
            return p;
        }

        public long[] readAllLongs(int n, int s) {
            long[] p = new long[n + s];
            for (int i = s; i < n + s; i++) {
                p[i] = in.nextLong();
            }
            return p;
        }

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

    static void exit(int a) {
        out.close();
        err.close();
        System.exit(a);
    }

    static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static OutputStream errStream = System.err;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);
    static PrintWriter err = new PrintWriter(errStream);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

}

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

public class E {
    public static void main(String args[]) {
        Scanner cin = new Scanner(System.in);
        int n=cin.nextInt();
        if (n == 2) {
            System.out.println(1);
        }
        else {
            BigInteger sum = new BigInteger("1");
            for (int i = (n / 2 + 1); i <= n; ++i) {
                sum = sum.multiply(BigInteger.valueOf(i));
            }
            for (int i = 1; i <= n / 2; ++i) {
                sum = sum.divide(BigInteger.valueOf(i));
            }
            for (int i = 1; i <= n / 2 - 1; ++i) {
                sum = sum.multiply(BigInteger.valueOf(i * i));
            }
            System.out.println(sum.divide(BigInteger.valueOf(2)));
        }
    }
}

import java.util.Scanner;

public class TwoRoundDances {

    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(factorial(n)/((int)(0.5*Math.pow(n,2))));
        sc.close();
    }

    public static long factorial(int n)
    {
        if(n == 1)
            return 1;

        return n * factorial(n-1);
    }
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{

  public static void main (String[] args) throws java.lang.Exception
   {
	try{
	     //long a=Long.parseLong(next());
	    // int a=sc.nextInt();
	     Reader sc=new Reader();
	     PrintWriter out=new PrintWriter(System.out);
	     String ans[]={"1", "3", "40", "1260", "72576", "6652800", "889574400", "163459296000", "39520825344000", "12164510040883200"};
		 int n=sc.nextInt();
		 out.println(ans[n/2-1]);

	out.flush();
	out.close();
	   }
	catch(Exception e)
		 {}
	}
	//Template
  // static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   //  static PrintWriter pw = new PrintWriter(System.out);
   //  static StringTokenizer st;

   //  static String next()
   //     {
   //          while(st==null || !st.hasMoreElements())
   //          {
   //              try
   //              {
   //                 st = new StringTokenizer(br.readLine());
   //              }
   //              catch(IOException e)
   //              {
   //                 e.printStackTrace();
   //              }
   //          }
   //          return st.nextToken();
   //     }
   // static int gcd(int a,int b)
   //  {
   //     if(b==0)
   //     return a;
   //     else
   //     return gcd(b,a%b);
   //  }

    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

}

import java.util.*;
public class Two_Round_Dances {
    public static Scanner scan = new Scanner(System.in);
    public static long factorial(int n){
        long fact = 1;
        for (int i=1;i<=n;i++){
            fact*=i;
        }
        return fact;
    }

    public static void main(String[] args) {
        int n=scan.nextInt();
        long answer = (long) (factorial(n)/Math.pow(n/2,2)/2);
        System.out.println(answer);
    }
}

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

public class CodeForce_Round_677_Div3_ProblemE_TwoRoundDances {

    public static void main(String[] args) {
        process();
    }

    public static void process() {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        long ret = solve(n);
        System.out.println(ret);
    }

    public static long solve(int n) {
        long ret = 1;
        // 1. take all position combinations
        for(int i = 1; i <= n; ++i) {
            ret *= i;
        }

        // 2. for each round in each part, there are n/2 cases, so in total there are (n/2) * (n/2) cases
        ret /= (n/2) * (n/2) ;

        // 3. also, there is no order of two parts, so the result will still need to be devided by 2
        return ret/2;
    }

}

import java.util.Scanner;

public class fifthProg {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		long arr[] = { 1, 3, 40, 1260, 72576, 6652800, 889574400, 163459296000l, 39520825344000l, 12164510040883200l };
		System.out.println(arr[(n / 2) - 1]);
	}
}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner sc=new Scanner(System.in);

         long n=sc.nextLong();
         if (n==2)
         System.out.println("1");
         else if(n==4)
         System.out.println("3");
         else
         {
         long x=factorial(n-1);
         long y=((x/n)*2);
         System.out.println(y);
         }

    }

static long factorial(long a)
{
    long fact=1;
     for(long i=1;i<=a;i++)
      fact=fact*i;
      return fact;
}
}

import java.util.Scanner;

public class Main {
	 static long factorial(long n){
		  if (n == 0)
		    return 1;
		  else
		    return(n * factorial(n-1));
	}
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()) {
			long s = sc.nextInt();
			System.out.println((long) factorial(s) / s / (s/2));
		}
	}
}

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 E_Round_677_Div3 {
    public static long MOD = 1000000007;
    static int[][][][] dp;

    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();
        long result = 1;
        for (int i = n - 1; i > n / 2; i--) {
            result *= i;
        }
        for (int i = n / 2 - 1; i > 0; i--) {
            result *= i;
        }
        out.println(result);
        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 Integer.compare(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, int b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }

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

        }
    }

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

//package com.company;
import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int n = Integer.parseInt(br.readLine());
        long ans = 1;
        for(int i=1;i<n;i++) ans*=i;
        pw.println(2*ans/n);
        pw.flush();
        pw.close();
    }
}

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

public class Solution {

    private static FastReader in = new FastReader();
    public static void main(String[] args) throws Exception {
        // int t = in.nextInt();
        // while (t-- > 0) {
            solve();
        // }
    }

    static void solve() {
        int n = in.nextInt();
        long sum = 1;
        for(int i=1; i<=n; i++)  sum *= i;
        sum *= 2;
        sum = sum / (long)Math.pow(n, 2);

        System.out.println(sum);
    }
}

class Pair{
    Integer a, b;
    Pair(int a, int b){
        this.a = a;
        this.b = b;
    }
}

class FastReader {
    BufferedReader br;
    StringTokenizer st;

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

import java.io.*;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class E {
    static FastReader reader = new FastReader();

    static long fac(long n) {
        long res = 1;
        for(long i = 2; i <= n; i++) {
            res *= i;
        }
        return res;
    }

    public static void main(String[] args) {
        long n = reader.nextInt();
        long nom = fac(n);
        long dom = fac(n/2);
        long res = (nom / (dom * dom))/ 2;
        long mult = (dom / (n/2));
        res *= (mult *mult);
        System.out.println(res);
    }

    static final Random random = new Random();

    static void shuffleSort(int[] a) {
        int n = a.length;//shuffle, then sort
        for (int i = 0; i < n; i++) {
            int oi = random.nextInt(n), temp = a[oi];
            a[oi] = a[i];
            a[i] = temp;
        }
        Arrays.sort(a);
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

    public 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(char[] array) {
            writer.print(array);
        }

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

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

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

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

        public void println(int[] array) {
            print(array);
            writer.println();
        }

        public void println(double[] array) {
            print(array);
            writer.println();
        }

        public void println(long[] array) {
            print(array);
            writer.println();
        }

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

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

        public void print(char i) {
            writer.print(i);
        }

        public void println(char i) {
            writer.println(i);
        }

        public void println(char[] array) {
            writer.println(array);
        }

        public void printf(String format, Object... objects) {
            writer.printf(format, objects);
        }

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

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

        public void print(long i) {
            writer.print(i);
        }

        public void println(long i) {
            writer.println(i);
        }

        public void print(int i) {
            writer.print(i);
        }

        public void println(int i) {
            writer.println(i);
        }

        public void separateLines(int[] array) {
            for (int i : array) {
                println(i);
            }
        }
    }
}

import java.io.*;
import java.lang.*;
import java.util.*;
public class Solution{
    public static void main(String[] args){
      Scanner scan = new  Scanner(System.in);
      int n = scan.nextInt();
      long ans = 1;
      for(int i=1;i<=n;i++){
          ans=ans*(i);

      }
      System.out.println(ans/((n/2)*(n/2)*2));

    }

}

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

        public class Main implements Runnable
        {
            static class InputReader
            {
                private InputStream stream;
                private byte[] buf = new byte[1024];
                private int curChar;
                private int numChars;
                private SpaceCharFilter filter;
                private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

                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 String nextLine()
                {
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    return str;
                }
                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 long nextLong()
                {
                    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 double nextDouble()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    double res = 0;
                    while (!isSpaceChar(c) && c != '.')
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    if (c == '.')
                    {
                        c = read();
                        double m = 1;
                        while (!isSpaceChar(c))
                        {
                            if (c == 'e' || c == 'E')
                                return res * Math.pow(10, nextInt());
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            m /= 10;
                            res += (c - '0') * m;
                            c = read();
                        }
                    }
                    return res * sgn;
                }

                public String readString()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    StringBuilder res = new StringBuilder();
                    do
                    {
                        res.appendCodePoint(c);
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res.toString();
                }

                public boolean isSpaceChar(int c)
                {
                    if (filter != null)
                        return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                }

                public String next()
                {
                    return readString();
                }

                public interface SpaceCharFilter
                {
                    public boolean isSpaceChar(int ch);
                }
            }
            public static void main(String args[]) throws Exception
            {
                new Thread(null, new Main(),"Main",1<<27).start();
            }

            static class Pair{
                int f;
                int s;
                PrintWriter w;

                //int t;

                // Pair(int f,int s,int t){
                Pair(int f,int s, PrintWriter w){
                    this.f = f;
                    this.s = s;
                    this.w = w;
                    //this.t = t;

                }

                public static Comparator<Pair> wc = new Comparator<Pair>(){
                    public int compare(Pair e1,Pair e2){

                        //1 for swap
                        if(Math.abs(e1.f)-Math.abs(e2.f)!=0){
                            //e1.w.println("**"+e1.f+" "+e2.f);
                            return (Math.abs(e1.f)-Math.abs(e2.f));
                        }
                        else{
                            //e1.w.println("##"+e1.f+" "+e2.f);
                            return (Math.abs(e1.s)-Math.abs(e2.s));
                        }

                    }
                };
            }

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

            ////recursive BFS
            public static int bfsr(int s,ArrayList<Integer>[] a,boolean[] b,int[] pre){
                b[s]=true;
                int p = 1;
                int n = pre.length -1;
                int t = a[s].size();
                int max = 1;
                for(int i=0;i<t;i++){
                    int x = a[s].get(i);
                    if(!b[x]){
                        //dist[x] = dist[s] + 1;
                        int xz =  (bfsr(x,a,b,pre));
                        p+=xz;
                        max = Math.max(xz,max);
                    }
                }
                //max = Math.max(max,(n-p));
                pre[s] = max;
                return p;
            }

        //// iterative BFS
            public static int bfs(int s,ArrayList<Integer>[] a,int dist,boolean[] b,PrintWriter w){
                b[s]=true;
                int siz = 0;
                dist--;
                Queue<Integer> q = new LinkedList<>();
                q.add(s);
                while(q.size()!=0 && dist>0 ){
                    int i=q.poll();
                    Iterator<Integer> it = a[i].listIterator();
                    int z=0;
                    while(it.hasNext() && dist>0){
                        z=it.next();
                        if(!b[z]){
                            b[z]=true;
                            dist--;
                            //dist[z] = dist[i] + 1;
                            siz++;
                            q.add(z);
                        }
                    }

                }
                return siz;
            }

            public static int lower(int key, Integer[] a){
                int l = 0;
                int r = a.length-1;
                int res = 0;

                while(l<=r){
                    int mid = (l+r)/2;

                    if(a[mid]<=key){
                        l = mid+1;
                        res = mid+1;
                    }
                    else{
                        r = mid -1;
                    }
                }

                return res;
            }

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

            public void run()
            {
                InputReader sc = new InputReader(System.in);
                PrintWriter w = new PrintWriter(System.out);
                long defaultValue = 0;

                // int tc = sc.nextInt();
                // while(tc-->0){

                    long n = sc.nextLong();
                    long x = 1;
                    for(int i=1;i<=n;i++)x=x*i;
                    x = (2*x)/(n*n);
                    w.println(x);

                 //}
                w.flush();
                w.close();
            }

        }

import java.util.*;

//1st time using unionfind....
//firstly checked ishaan2908's solution...

public class cp{

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

			long num = sc.nextInt();

			long fact = fact(num-1);

			System.out.println(fact/(num/2));

	}

	 static long fact(long num)
	 {
	 	long res = 1;

	 	for(long i=num;i>1;i--)
	 	{
	 		res*=i;
	 	}

	 	return res;
	 }

}

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.InputMismatchException;
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author ujjwal abhishek
 */
public class E
{
    public static void solve()
    {
        int n=sc.nextInt();
        long ans=factorial(n)/(factorial(n/2)*factorial(n/2));
        ans*=factorial(n/2-1)*factorial(n/2-1);
        out.println(ans/2);
    }
    public static void main(String[] args)
    {
        new Thread(null, null, "Thread", 1 << 27)
        {
            public void run()
            {
                try
                {
                    out = new PrintWriter(new BufferedOutputStream(System.out));
                    sc = new FastReader(System.in);
                    solve();
                    out.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }
                .start();
    }
    static final Random random=new Random();
    static long factorial(int n)
    {
        long k=1;
        for (int i=1;i<=n;i++) k*=i;
        return k;
    }
    static void UjjwalSort(int[] a)
    {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++)
        {
            int ujjwal=random.nextInt(n), temp=a[ujjwal];
            a[ujjwal]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }
    public static PrintWriter out;
    public static FastReader sc;
    public static class FastReader
    {
        private InputStream stream;
        private byte[] buf = new byte[4096];
        private int curChar, snumChars;
        public FastReader(InputStream stream)
        {
            this.stream = stream;
        }
        public int read()
        {
            if (snumChars == -1)
            {
                throw new InputMismatchException();
            }
            if (curChar >= snumChars)
            {
                curChar = 0;
                try
                {
                    snumChars = stream.read(buf);
                }
                catch (IOException E)
                {
                    throw new InputMismatchException();
                }
            }
            if (snumChars <= 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 number = 0;
            do
            {
                number *= 10;
                number += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return number * sgn;
        }
        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            long sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            long number = 0;
            do
            {
                number *= 10L;
                number += (long) (c - '0');
                c = read();
            } while (!isSpaceChar(c));
            return number * sgn;
        }
        public int[] nextIntArray(int n)
        {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++)
            {
                arr[i] = this.nextInt();
            }
            return arr;
        }
        public long[] nextLongArray(int n)
        {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++)
            {
                arr[i] = this.nextLong();
            }
            return arr;
        }
        public String next()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
        public String nextLine()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndofLine(c));
            return res.toString();
        }
        public boolean isSpaceChar(int c)
        {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
        public boolean isEndofLine(int c)
        {
            return c == '\n' || c == '\r' || c == -1;
        }
    }
}

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

public class a2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc= new Scanner(System.in);
		//long t=sc.nextLong();
		long t=1;
		long[] d = new long[21];
		d[0]=1;
		for(int i=1;i<=20;i++) {
			d[i]=d[i-1]*i;
		}
		while(t!=0) {
			int n = sc.nextInt();

//			int[] a = new int[n];
//			int x=1,b=-1;
//			for(int i=0;i<n;i++) {
//				a[i] = sc.nextInt();
//				if(i==0) {
//					b=a[i];
//				}
//				else if(a[i]==b) {
//					x++;
//				}
//			}
			//Arrays.sort(a);

			long ans=(d[n]*2)/(n*n);

			System.out.println(ans);
			t--;
		}
		sc.close();
	}

}

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

public class GFG {

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

	   int size=sc.nextInt();
	   int a[]=new int[size];
long sum=1;
	   for(int u=1;u<=size;u++){
	       sum=sum*u;
	   }
	   sum=sum/(size/2);
	   sum=sum/size;
	   System.out.println(sum);

}
}

import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger;
public final class codeforces
{
    static StringBuilder ans=new StringBuilder();;
    static FastReader in=new FastReader();
    static ArrayList<ArrayList<Integer>> g=new ArrayList<ArrayList<Integer>>();
    static long mod=1000000007;
    static boolean set[];
    //main method
    //main method
    //main method
    //main method
    public static void main(String args[])
    {
        int N=in.nextInt();
        if(N==2)
        {
            System.out.println(1);
            return;
        }
        if(N==4)
        {
            System.out.println(3);
            return;
        }
        int n2=N/2;
        long s=1;
        for(int i=1; i<n2; i++)
            s*=i;
        set();
        long n=nCr(N,n2);
        n/=2;
        System.out.println(s*s*n);
    }
    static long dp[][]=new long[30][30];
    static void set()
    {
        for(int i=0; i<30; i++)
        {
            for(int j=0; j<30; j++)dp[i][j]=-1;
        }
    }

    static long nCr(int N, int r)
    {
        if(r==0 || r==N)return 1;
        if(dp[N][r]!=-1)return dp[N][r];
        return dp[N][r]=nCr(N-1,r-1)+ nCr(N-1,r);
    }

    static boolean lucky(long a)
    {
        String X=a+"";
        for(int i=0; i<X.length(); i++)
        {
            char ch=X.charAt(i);
            if(ch!='4' && ch!='7')return false;

        }
        return true;
    }

    static long nextLucky(long x)
    {
        String X=x+"";
        String y="";
        boolean f=true;
        for(int i=X.length()-1; i>=0; i--)
        {
            char ch=X.charAt(i);
            if(ch=='4' && f)
            {
                y=7+y; f=false;
            }
            else if(f) y=4+y;
            else y=ch+y;
        }

        if(f)
        {
            if(X.charAt(0)=='7')
                y=4+y;
            else y=4+X.substring(1);
        }
        return Long.parseLong(y);
    }

    static void setGraph(int N)//intialize graph here
    {
        for(int i=0; i<=N; i++)
            g.add(new ArrayList<Integer>());
    }

    static void DFS(int N,int d)
    {
        set[N]=true;
        d++;
        //max=Math.max(max,d);
        for(int i=0; i<g.get(N).size(); i++)
        {
            int c=g.get(N).get(i);
            if(set[c]==false)
            {
                DFS(c,d);
            }
        }
    }

    static int countBits(long a)
    {
        return (int)(Math.log(a)/Math.log(2)+1);
    }
    //fucntions
    //fucntions
    //fucntions
    //fucntions
    static int[] input(int A[]) //input of Int Array
    {
        int N=A.length;
        for(int i=0; i<N; i++)
        {
            A[i]=in.nextInt();
        }
        return A;
    }

    static long[] inputLong(int N) //Input of long Array
    {
        long A[]=new long[N];
        for(int i=0; i<A.length; i++)A[i]=in.nextLong();
        return A;
    }

    static int GCD(int a,int b) //wrong output if a ||b are intially zero
    {
        if(b==0)
        {
            return a;
        }
        else return GCD(b,a%b );
    }

    static boolean isPrime(int N)
    {
        for(int i=2; i*i<N; i++)
            if(N%i==0)return false;
        return true;
    }

}
//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
class FastReader
{
    BufferedReader br;
    StringTokenizer st;
    public FastReader()
    {
        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;
    }

}

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

public class Main {
    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            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 class Solution{
        private long  fact(long n){
            long ans = 1;
            for(long i=1;i<=n;i++){
                ans *= i;
            }
            return ans;
        }
        private  long comb(long n , long r){
            return  fact(n) / (fact(r) * fact(n - r));
        }
        public long solve(long n){
            long t1 = comb(n, n/2)/2;
            long t2 = fact(n/2) / (n/2);
            return t1 * t2 * t2;
        }
    }
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        Solution s = new Solution();
        System.out.println(s.solve(sc.nextInt()));
    }
}

import java.util.*;
public class Two_Round_Dances {
    public static Scanner scan = new Scanner(System.in);
    public static long factorial(int n){
        long fact = 1;
        for (int i=1;i<=n;i++){
            fact*=i;
        }
        return fact;
    }

    public static void main(String[] args) {
        int n=scan.nextInt();
        long answer = (long) (factorial(n)/Math.pow(n/2,2)/2);
        System.out.println(answer);
    }
}

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

public class Main{
	static long fac(long l) {
		int j = 1;
		for (int i = 2; i <= l; i++) {
			j *= i;
		}
		return j;
	}
   public static void main(String[] args) throws IOException{

		long res = 1;
		long n = sc.nextInt();
		for (int i = 1; i <= n; i++) {
			res *= i;
		}
		for (int j = 0; j < 2; j++) {
			for (int i = 1; i <= n/2; i++) {
				res /= i;
			}
		}
		res/=2;

		out.println(res * pow(fac(n/2-1),2));

	out.close();
   }
   static long ceil(long a, long b) {
		return (a+b-1)/b;
	}

   static long powMod(long base, long exp, long mod) {
	   if (base == 0 || base == 1) return base;
	   if (exp == 0) return 1;
	   if (exp == 1) return base % mod;
	   long R = powMod(base, exp/2, mod) % mod;
	   R *= R;
	   R %= mod;
	   if ((exp & 1) == 1) {
		   return base * R % mod;
	   }
	   else return R % mod;
   }

   static long pow(long base, long exp) {
	   if (base == 0 || base == 1) return base;
	   if (exp == 0) return 1;
	   if (exp == 1) return base;
	   long R = pow(base, exp/2);
	   if ((exp & 1) == 1) {
		   return R * R * base;
	   }
	   else return R * R;
   }

   static class Reader
   {
       final private int BUFFER_SIZE = 1 << 16;
       private DataInputStream din;
       private byte[] buffer;
       private int bufferPointer, bytesRead;

       public Reader()
       {
           din = new DataInputStream(System.in);
           buffer = new byte[BUFFER_SIZE];
           bufferPointer = bytesRead = 0;
       }

       public Reader(String file_name) throws IOException
       {
           din = new DataInputStream(new FileInputStream(file_name));
           buffer = new byte[BUFFER_SIZE];
           bufferPointer = bytesRead = 0;
       }

       public String readLine() throws IOException
       {
           byte[] buf = new byte[64]; // line length
           int cnt = 0, c;
           while ((c = read()) != -1)
           {
               if (c == '\n')
               {
            	   break;
               }
               buf[cnt++] = (byte) c;
           }
           return new String(buf, 0, Integer.max(cnt-1, 0));
       }

       public int nextInt() throws IOException
       {
           int ret = 0;
           byte c = read();
           while (c <= ' ')
               c = read();
           boolean neg = (c == '-');
           if (neg)
               c = read();
           do
           {
               ret = ret * 10 + c - '0';
           }  while ((c = read()) >= '0' && c <= '9');

           if (neg)
               return -ret;
           return ret;
       }

       public long nextLong() throws IOException
       {
           long ret = 0;
           byte c = read();
           while (c <= ' ')
               c = read();
           boolean neg = (c == '-');
           if (neg)
               c = read();
           do {
               ret = ret * 10 + c - '0';
           }
           while ((c = read()) >= '0' && c <= '9');
           if (neg)
               return -ret;
           return ret;
       }

       public double nextDouble() throws IOException
       {
           double ret = 0, div = 1;
           byte c = read();
           while (c <= ' ')
               c = read();
           boolean neg = (c == '-');
           if (neg)
               c = read();

           do {
               ret = ret * 10 + c - '0';
           }
           while ((c = read()) >= '0' && c <= '9');

           if (c == '.')
           {
               while ((c = read()) >= '0' && c <= '9')
               {
                   ret += (c - '0') / (div *= 10);
               }
           }

           if (neg)
               return -ret;
           return ret;
       }

       private void fillBuffer() throws IOException
       {
           bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
           if (bytesRead == -1)
               buffer[0] = -1;
       }

       private byte read() throws IOException
       {
           if (bufferPointer == bytesRead)
               fillBuffer();
           return buffer[bufferPointer++];
       }

       public void close() throws IOException
       {
           if (din == null)
               return;
           din.close();
       }
   }

	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	public static Reader sc = new Reader();
}

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

@SuppressWarnings("unchecked")
public class E{

    public static long fact(int n){
        if(n==0 || n==1)
        return n;

        return n*fact(n-1);
    }

    public static void main(String args[])throws IOException{
        int n=sc.nextInt();
        long f1 = fact(n);
        long f2 = fact(n/2);
        long f3 = f2/(n/2);

        long res= (f1/(f2*f2))*f3*f3/2;
        out.println(res);
        out.close();
    }

    static int M=(int)Math.pow(10,9)+7;

    public static void sort(int[] arr,boolean reverse){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int n =arr.length;
        for(int i=0;i<n;i++){
            list.add(arr[i]);
        }

        if(reverse)
        Collections.sort(list,Collections.reverseOrder());
        else
        Collections.sort(list);

        for(int i=0;i<n;i++){
            arr[i] = list.get(i);
        }
    }

    public static double min(double ...a){
        double min=Double.MAX_VALUE;
        for(double i : a)
        min =Math.min(i,min);
        return min;
    }

    public static long min(long ...a){
        long min=Long.MAX_VALUE;
        for(long i : a)
        min =Math.min(i,min);
        return min;
    }

    public static int min(int ...a){
        int min=Integer.MAX_VALUE;
        for(int i : a)
        min =Math.min(i,min);
        return min;
    }

    public static double max(double ...a){
        double max=Double.MIN_VALUE;
        for(double i : a)
        max =Math.max(i,max);
        return max;
    }

    public static long max(long ...a){
        long max=Long.MIN_VALUE;
        for(long i : a)
        max =Math.max(i,max);
        return max;
    }

    public static int max(int ...a){
        int max=Integer.MIN_VALUE;
        for(int i : a)
        max =Math.max(i,max);
        return max;
    }
    static class Pair{

        // Implementing equals() and hashCode()
        // Map<Pair, V> map = //...

        private final int x;
        private final int y;

        public Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Pair)) return false;
            Pair pair = (Pair) o;
            return x == pair.x && y == pair.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }
    }

    static FastScanner sc = new FastScanner();
    static PrintWriter out =new PrintWriter(System.out);

    static class FastScanner {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer st=new StringTokenizer("");
            String next() {
                while (!st.hasMoreTokens())
                    try {
                        st=new StringTokenizer(br.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                return st.nextToken();
            }

            int nextInt() {
                return Integer.parseInt(next());
            }
            int[] readArray(int n) {
                int[] a=new int[n];
                for (int i=0; i<n; i++) a[i]=nextInt();
                return a;
            }
            long nextLong() {
                return Long.parseLong(next());
            }
            public long[] readLongArray(int n) {
                long[] a=new long[n];
                for (int i=0; i<n; i++) a[i]=nextLong();
                return a;
            }
    }
}

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

public class Main
{
	public static void main(String[] args) {
		new Thread(null, new Runnable() {
			public void run() {
				FastReader fr =new FastReader();	PrintWriter op =new PrintWriter(System.out);

				int T =1 ;

                while (T-->0)
                	solve(fr , op);
                op.flush();	op.close();
            }
        }, "1", 1 << 26).start();
	}
	static void solve (FastReader fr , PrintWriter op) {
 		long fact =1l ,N =fr.nextLong() ,i ;

 		for (i =2 ; i<N ; ++i) {
 			if (2*i==N)
 				continue;
 			fact *= i ;
 		}
 		op.println(fact) ;
	}
	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

		String nextLine() {
			String str ="";

			try
			{
				str =br.readLine();
			}
			catch(IOException e)
			{
				e.printStackTrace();
			}

			return str;
		}

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

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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Solution {

   static ArrayList<ArrayList<Integer>> list;
	static int count=0;
	public static void main(String[] args)
    {
		FastReader fr=new FastReader();
         int n=fr.nextInt();
         long f=facto(n);
         long ff=facto(n/2);
         long d=f/(ff*ff);
         d=d/2;
          long v1=facto(n/2-1);

          System.out.println(d*v1*v1);

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

}
class FastReader
{
    BufferedReader br;
    StringTokenizer st;

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

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class RoundTwo {

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			System.out.println(roundTwo(Integer.parseInt(scanner.nextLine())));
		}

//		System.out.println(roundTwo(8));
//		System.out.println(roundTwo(20));

//		System.out.println(permutationCnt(8));
//		System.out.println(permutationCnt(20));
	}

	private static long roundTwo(int n) {
		long cnt = permutationCnt(n);
		long numerator = 1;
		long denominator = 1;
		for(int i=1;i<=n;i++)
		{
			numerator *= i;
			if(i <= n/2)
				denominator *= i*i;
		}
		cnt *= cnt;
		cnt *= numerator/denominator;
		return cnt/2;
	}

	private static long permutationCnt(int n) {
		long cnt = 0;
		int h = n / 2;

		char[] ca = new char[h];

		for(int i=0;i<h;i++) {
			ca[i] = (char)('a'+i);
		}
		Set<String> set = new HashSet<>();
		do
		{
			StringBuilder temp = new StringBuilder();
			for(char x : ca)
				if(x != 'a')
					temp.append(x);

			final String k = temp.toString();
			if(!set.contains(k))
			{
				cnt++;
				set.add(k);
			}
		}while(findNextPermutation(ca));
		return cnt;
	}

	private static char[] swap(char data[], int left, int right) {

		// Swap the data
		char temp = data[left];
		data[left] = data[right];
		data[right] = temp;

		// Return the updated array
		return data;
	}

	private static char[] reverse(char data[], int left, int right) {

		// Reverse the sub-array
		while (left < right) {
			char temp = data[left];
			data[left++] = data[right];
			data[right--] = temp;
		}

		// Return the updated array
		return data;
	}

	private static boolean findNextPermutation(char data[]) {
		if (data.length <= 1)
			return false;

		int last = data.length - 2;

		while (last >= 0) {
			if (data[last] < data[last + 1]) {
				break;
			}
			last--;
		}

		if (last < 0)
			return false;

		int nextGreater = data.length - 1;

		for (int i = data.length - 1; i > last; i--) {
			if (data[i] > data[last]) {
				nextGreater = i;
				break;
			}
		}

		data = swap(data, nextGreater, last);

		data = reverse(data, last + 1, data.length - 1);

		return true;
	}
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
    static long fact(int n){
         long ans = 1;
         for(int i=n;i>1;i--) ans = ans*i;

         return ans;
     }
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		 Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		int n = sc.nextInt();

		double ans = fact(n)/(Math.pow(n/2,2)*2);

		System.out.println((long)ans);

	}
}

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

public class E {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            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 FastReader s = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    private static int[] rai(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextInt();
        }
        return arr;
    }

    private static int[][] rai(int n, int m) {
        int[][] arr = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextInt();
            }
        }
        return arr;
    }

    private static long[] ral(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextLong();
        }
        return arr;
    }

    private static long[][] ral(int n, int m) {
        long[][] arr = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextLong();
            }
        }
        return arr;
    }

    private static int ri() {
        return s.nextInt();
    }

    private static long rl() {
        return s.nextLong();
    }

    private static String rs() {
        return s.next();
    }

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

    static int bsearch(List<Long> list,long val,int ind)
    {
        int l=ind,r=list.size()-1;
        int res=list.size();

        while(l<=r)
        {
            int mid=(l+r)/2;
            if(list.get(mid)>val)
            {
                if(mid==0)
                {
                    return mid;
                }
                if(list.get(mid-1)<=val)
                {
                    return mid;
                }
                r=mid-1;
            }
            else
            {
                l=mid+1;
            }
        }
        return res;

    }

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
//        int t = ri();
        long[] fact=new long[21];
        fact[0]=1;
        for(int i=1;i<21;i++)
        {
            fact[i]=i*fact[i-1];
        }
        long[] val=new long[21];
        val[2]=1;
        val[1]=1;
        for(int i=3;i<=20;i++)
        {
            val[i]=(i-1)*val[i-1];
        }
        int t = 1;
        while (t-- > 0) {
            int n=ri();

            long res=(fact[n])/(2*fact[n/2]*fact[n/2]);
            res*=val[n/2]*val[n/2];
            ans.append(res).append("\n");

        }
        out.print(ans.toString());
        out.flush();

    }

}

import java.io.*;

public class TwoRoundDance {
    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }
            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }

    static Reader sc = new Reader();
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    public static void main(String args[]) throws IOException {
        int n = inputInt();
       int r = n/2;
       long ans = ((fact(n)/((fact(r)) * (fact(n-r)))) / 2 ) * (fact(r-1)) * fact(r-1);
       println(ans+"");

        bw.flush();
        bw.close();
    }
    public static long fact(int n){
        if(n <= 1)
            return 1;
        return n * fact(n-1);
    }

    public static int inputInt() throws IOException {
        return sc.nextInt();
    }

    public static long inputLong() throws IOException {
        return sc.nextLong();
    }

    public static double inputDouble() throws IOException {
        return sc.nextDouble();
    }

    public static String inputString() throws IOException {
        return sc.readLine();
    }

    public static void print(String a) throws IOException {
        bw.write(a);
    }

    public static void printSp(String a) throws IOException {
        bw.write(a + " ");
    }

    public static void println(String a) throws IOException {
        bw.write(a + "\n");
    }
}

import java.util.Scanner;

public class E {
	public static long fct(long x){
		if(x==1)return 1;
		else return x*fct(x-1);
	}
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		long n=scanner.nextLong();
		if(n==2)System.out.println(1);
		else
		System.out.println((fct(n)/fct(n/2)/fct(n/2))*(fct(n/2-1)*fct(n/2-1))/2);

	}
}

import java.util.Scanner;

public class L111 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
		while(scan.hasNext()){
			int n=scan.nextInt();
			long sum=1;
			for(int i=1;i<n;i++)
			{
				sum*=i;
			}
			System.out.println(sum/(n/2));
	}
	}
}

import java.util.*;
//import java.math.*;

public class Codeforces {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long[] arr = new long[25];
        arr[1] = 1;
        for (int i = 2; i <= n; ++i) {
            arr[i] = arr[i - 1] * i;
        }
        System.out.println(arr[n] / n / (n / 2));
    }
}

import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        long fact = 1;
        for(int i = 2; i < n; i++){
            fact = fact * i;
        }
        fact = (2 * fact)/n;
        System.out.println(fact);

    }
}

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

public class Main {
	public static void main (String[] args) {
	   // Scanner scan = new Scanner(System.in);
    	FastScanner scan = new FastScanner();
        long n = scan.nextLong();
        long fact = findFact(n - 1);
        System.out.println(fact / (n / 2));
    }

    static long findFact(long n) {
        long ans = 1;
        for(long i = n; i >= 1; i--) {
            ans *= i;
        }

        return ans;
    }
/*

            int[] arr = new int[n];
            for(int i = 0; i < n; i++) {
                arr[i] = scan.nextInt();
            }

    long n = scan.nextLong();
            long[] arr = new long[n];
            for(int i = 0; i < n; i++) {
                arr[i] = scan.nextLong();
            }

*/

    static class FastScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}

}

import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;

   public class E
   {
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         BigInteger res = new BigInteger("1");
         for(int i=N-1; i >= 1; i--)
            res = res.multiply(new BigInteger(i+""));
         res = res.divide(new BigInteger(N/2+""));
         System.out.println(res.longValue());
      }
   }

import java.util.*;

public class Ta{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);

           long n=sc.nextLong();
           long sum=1;
           for(long i=1;i<n;i++){
            sum*=i;
           }
           long k=n/2;

           System.out.println(sum/k);

       }

 }

import java.util.*;
public class E {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long ans = 1;
        for (int i = 0; i < n; i++) {
            ans*=i+1;
        }
        ans/=Math.pow(n/2,2)*2;
        System.out.println(ans);
        in.close();
    }
}

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

public class Codewars {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int count = Integer.parseInt(scanner.nextLine());
		BigInteger result = BigInteger.ONE;
		for (int i = 2; i <= count-1; ++i) {
			result = result.multiply(BigInteger.valueOf(i));
		}
		System.out.println(count == 2 ? 1 : result.divide(BigInteger.valueOf(count/2)));
	}
}

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

public class E {
    public static void main(String[] args) throws IOException {
        FastScanner fs=new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        // int T = 1;

        // int T=fs.nextInt();
        // for (int tt=0; tt<T; tt++) {
            int n  = fs.nextInt();
            long ans =1 ;
            for (int i=1; i<=n-1; i++) {
                ans*=i;
            }
            ans=ans/(n/2);
            out.println(ans);
        // }

        out.close();
    }

    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n), temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner sc=new Scanner(System.in);

         long n=sc.nextLong();
         if (n==2)
         System.out.println("1");
         else if(n==4)
         System.out.println("3");
         else
         {
         long x=factorial(n-1);
         long y=((x/n)*2);
         System.out.println(y);
         }

    }

static long factorial(long a)
{
    long fact=1;
     for(long i=1;i<=a;i++)
      fact=fact*i;
      return fact;
}
}

import java.util.*;
public class Ta{
public static void main(String[] args) {Scanner sc=new Scanner(System.in);
long n=sc.nextLong(); long sum=1;for(long i=1;i<n;i++){sum*=i;}
long k=n/2;System.out.println(sum/k);} }

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

public class Solution_1433E {
    public static void main(String[] args) {
        long[] arr = new long[]{1L, 3L, 40L, 1260L, 72576L, 6652800L, 889574400L, 163459296000L, 39520825344000L, 12164510040883200L};

        try {
            Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
            int a = in.nextInt();
            System.out.println(arr[a/2 -1]);

        } catch (Exception e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
        }
    }

    public static String arrToStr(int[][] arr) {
        StringBuilder str = new StringBuilder();
        for (int[] ints : arr) {
            String s = Arrays.toString(ints).replace(",", "");
            str.append("\n").append(s.substring(1, s.length() - 1));
        }
        return str.toString();
    }

}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.HashMap;
import java.util.Map;

public class Main {

public static void main(String[] args){

   new Thread(null, null, "Anshum Gupta", 99999999) {
        public void run() {
            try {
                solve();
            } catch(Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }.start();
}

static final long mxx = (long)(1e18 + 5), MOD = 998244353;
static final int mxN = (int)(1e6), mxV = (int)(1e6), log = 18, INF = (int)1e9;
static boolean[]vis;
static ArrayList<ArrayList<Integer>> adj = new ArrayList<ArrayList<Integer>>();
static int n, m, q, k;
static char[] str;
static long[] fact;

public static void solve() throws Exception {
	   // solve the problem here
		s = new MyScanner();
   		out = new PrintWriter(new BufferedOutputStream(System.out), true);
//	   		out = new PrintWriter("output.txt");
        int tc = 1;//s.nextInt();
    	for(int i=1; i<=tc; i++) {
//        	out.print("Case #" + i + ": ");
    		testcase();
    	}

        out.flush();
        out.close();
}

static void testcase() {
	int n = s.nextInt();

	// fix the start point
	// should not be a cyclic permutation
	// try all permutations
	// chose(n, n/2) * ((n/2 - 1)!) ^ 2 / 2

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

	long ans = chose(n, n / 2) * square(fact[n / 2 - 1]) / 2;

	out.println(ans);

}

private static long chose(int n, int r) {
	return fact[n] / fact[r] / fact[n - r];
}

private static long square(long l) {
	return l * l;
}

public static PrintWriter out;
public static MyScanner s;
static void shuffleArray(int[] a) {
	Random random = new Random();
	for (int i = a.length-1; i > 0; i--) {
		int index = random.nextInt(i + 1);
		int tmp = a[index];
		a[index] = a[i];
		a[i] = tmp;
	}
}
static void shuffleSort(int[] a) {
	shuffleArray(a);
	Arrays.parallelSort(a);
}
static class MyScanner {

    BufferedReader br;
    StringTokenizer st;

    public MyScanner() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }
    public MyScanner(String fileName) {
    	try {
			br = new BufferedReader(new FileReader(fileName));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
    }
    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()); }
    int[] nextIntArray(int n){
    	int[]a = new int[n];
    	for(int i=0; i<n; i++) {
    		a[i] = this.nextInt();
    	}
    	return a;
    }
    long[] nextlongArray(int n) {
    	long[]a = new long[n];
    	for(int i=0; i<n; i++) {
    		a[i] = this.nextLong();
    	}
    	return a;
    }
    Integer[] nextIntegerArray(int n){
    	Integer[]a = new Integer[n];
    	for(int i=0; i<n; i++) {
    		a[i] = this.nextInt();
    	}
    	return a;
    }
    Long[] nextLongArray(int n) {
    	Long[]a = new Long[n];
    	for(int i=0; i<n; i++) {
    		a[i] = this.nextLong();
    	}
    	return a;
    }
    char[][] next2DCharArray(int n, int m){
    	char[][]arr = new char[n][m];
    	for(int i=0; i<n; i++) {
    		arr[i] = this.next().toCharArray();
    	}
    	return arr;
    }
    ArrayList<ArrayList<Integer>> readUndirectedUnweightedGraph(int n, int m) {
    	ArrayList<ArrayList<Integer>>adj = new ArrayList<ArrayList<Integer>>();
    	for(int i=0; i<=n; i++)adj.add(new ArrayList<Integer>());
    	for(int i=0; i<m; i++) {
    		int u = s.nextInt();
    		int v = s.nextInt();
    		adj.get(u).add(v);
    		adj.get(v).add(u);
    	}
    	return adj;
    }
    ArrayList<ArrayList<Integer>> readDirectedUnweightedGraph(int n, int m) {
    	ArrayList<ArrayList<Integer>>adj = new ArrayList<ArrayList<Integer>>();
    	for(int i=0; i<=n; i++)adj.add(new ArrayList<Integer>());
    	for(int i=0; i<m; i++) {
    		int u = s.nextInt();
    		int v = s.nextInt();
    		adj.get(u).add(v);
    	}
    	return adj;
    }
    String nextLine(){
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

}

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

public class Main {

    public static long factorial(long n) {
        long res = 1;
        for(int i = 2; i <= n; i++)
            res *= i;
        return res;
    }

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        long n = read.nextInt();
        System.out.println((long)((factorial(n) / n) / (n * 0.5)));
    }
}

/*
We are counting the number of specific permutations:
formula: (n! / n) / (n * 0.5)
 */

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

public class E {

    public static void main(String[] args) {
        solve();
        out.close();
    }

    private static void solve() {
        int n = sc.nextInt();
        long ans = (long) (findFact(n-1)/(Math.floor((double) (n+1)/2)));
        out.println(ans);
    }

    public static long findFact(int i) {
        long prod = 1;
        for(int j = 2;j<=i;j++) prod *= j;

        return prod;
    }

    private static final FastScanner sc = new FastScanner();
    private static final PrintWriter out = new PrintWriter(System.out);

    public static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

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

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

import java.util.Scanner;

public class E {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		if(n==2) {
			System.out.println(1);
		}
		else {
			long ans = n;
			for(int i = n-1; i>n/2; i--) {
				ans*=i;
			}
			for(int i = n/2; i>0; i--) {
				ans/=i;
			}
			ans/=2;
			long circularP= n/2-1;
			for(int i= n/2-2; i>0; i--) {
				circularP *=i;
			}
			ans= ans*circularP*circularP;
			System.out.println(ans);
		}
	}

}

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.io.*;
import java.math.*;
/*
    *********************
  ***
 ***
 ***
 ***
 ***
   ***
     ***
       ***
*/
public class Cf
{

//INPUT READER//

    static 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 Int() {
            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 String String() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return String();
        }

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

    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 printLine(Object... objects) {
            print(objects);
            writer.println();
        }

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

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

    static InputReader in = new InputReader(System.in);
    static OutputWriter out = new OutputWriter(System.out);
    static int modulus = (int) 1e7;

    public static int[] sort(int[] a) {
        int n = a.length;
        ArrayList<Integer> l = new ArrayList<>();
        for (int i : a)
            l.add(i);
        Collections.sort(l);
        for (int i = 0; i < l.size(); i++)
            a[i] = l.get(i);
        return a;
    }

    public static long pow(long x, long y) {
        long res = 1;
        while (y > 0) {
            if (y % 2 != 0) {
                res = (res * x) % modulus;
                y--;

            }
            x = (x * x) % modulus;
            y = y / 2;
        }
        return res;
    }

    public static long gcd(long x, long y) {
        if (x == 0)
            return y;
        else
            return gcd(y % x, x);
    }

    public static long lcm(long x, long y) {
        return (x * (y / gcd(x, y)));
    }

    public static int i() {
        return in.Int();
    }

    public static long l() {
        String s = in.String();
        return Long.parseLong(s);
    }

    public static String s() {
        return in.String();
    }

    public static int[] readArray(int n) {
        int A[] = new int[n];
        for (int i = 0; i < n; i++) {
            A[i] = i();
        }
        return A;
    }

    public static long[] readArray(long n) {
        long A[] = new long[(int) n];
        for (int i = 0; i < n; i++) {
            A[i] = l();
        }
        return A;
    }

    static class pair {
        int x;
        int y;

        pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    static long fast_pow(long a, long b) {
         long mod = (long)1e9 + 7;
        if(b == 0)
            return 1L;

        long val = fast_pow(a, b / 2);

        if(b % 2 == 0)
            return val * val % mod;
        else
            return val * val % mod * a % mod;
    }

//-------------------------------------BFS------------------------------------------------------------------------------------------------------------------------------------//
    static ArrayList<Integer> bfs(ArrayList<ArrayList<Integer>> g, int n, int src)
    {
        ArrayList<Integer> p = new ArrayList<>();
        Queue<Integer> q = new LinkedList<>();
        Boolean visited[] = new Boolean[n];
        Arrays.fill(visited, false);

        visited[src] = true;
        q.add(src);
        while (q.size() != 0) {
            src = q.poll();
            p.add(src);
            Iterator<Integer> it = g.get(src).iterator();
            while (it.hasNext()) {
                int nn = it.next();

                if (visited[nn] == false) {
                    visited[nn] = true;
                    q.add(n);

                }
            }

        }
        return p;

    }
//--------------------------------------------------------DFS------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------- CODE--------------------------------------------------------------------------------------------------------------------//

    static void dfs(int i,int n)
    {
        if(!visited[i])
        {
            visited[i]=true;
            l.add(i);
        }
        for(int a:graph.get(i))
        {
            if(!visited[a])
            {

                dfs(a,n);

            }
        }

    }

//----------------------********************************MAIN FUNCTION IDHAR NHI AANE KA**********************************************--------------------------------------------------------------//
//***************************************************#$%&^%%%%^^&&--DEVIL---------------------------------------------------------------$%^&&***&&^^%%****************************
///////////////////////////////////////////////////////////////////CODER//////////////////////////////////////////////////////////////////////////////////////////////////////
   static ArrayList<ArrayList<Integer>>graph;
  static   boolean visited[];
  static long size;
  static ArrayList<Integer>l;

    public static void main(String[] args)
     {
         long pre[]=new long[21];
         pre[1]=(long)1;
         for(int i=2;i<21;i++)
         {
             pre[i]=i*pre[i-1];
         }
         StringBuffer sb=new StringBuffer();
       //int t=i();
       //while (t-->0)
       //{
           int n=i();
           long ans=0;
           int u=n/2;
           long k=(long)Math.pow(pre[u],2);
           ans=(long)pre[n]/k;
            ans=ans*pre[u-1]*pre[u-1]/2;

            if(n==2)
                ans=1;

        sb.append(ans+"\n");
      // }
       System.out.println(sb);

     }
}

import java.util.*;
import java.lang.*;
import java.io.*;
public class P1923
{
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		int a=s.nextInt();
		if(a==2)
			System.out.println(1);
		if(a==4)
			System.out.println(3);
		if(a==6)
			System.out.println(40);
		if(a==8)
			System.out.println(1260);
		if(a==10)
			System.out.println(72576);
		if(a==12)
			System.out.println(6652800);
		if(a==14)
			System.out.println("889574400");
		if(a==16)
			System.out.println("163459296000");
		if(a==18)
			System.out.println("39520825344000");
		if(a==20)
			System.out.println("12164510040883200");
	}
}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        long res = 1;
        for (int i=1; i<=n; i++) res*=i;
        for (int i=1; i<=n/2; i++) {
            res = res/i; res = res/i;
        }
        res = res/2;
        for (int i=1; i<(n/2); i++) {
            res*=i; res*=i;
        }
        System.out.println(res);
    }
}

import java.util.Scanner;
import java.util.Arrays;
public class Main {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		long a=input.nextInt();
		System.out.println(f(a)/f(a/2)/f(a/2)/2*f(a/2-1)*f(a/2-1));
	}
	public static long f(long a) {
		if(a>0)return a*=f(a-1);
		else return 1;
	}
}

import java.io.*;
import java.util.*;
	public class Sample {
		static int MOD = (int)1e7+9;
		static long fact[];
		public static void main(String[] args) throws Exception{
			Scanner input = new Scanner(System.in);
			int n = input.nextInt();
			fact = new long[21];
			fact[0] =1l; fact[1] =1l;
			for(int i =2;i<21;i++)fact[i] = fact[i-1]*i;
			long ans = nCr(n,n/2);
			//System.out.println(fact[(n/2)-1]);
			ans = ans * (fact[(n/2)-1]*fact[(n/2)-1]);
			System.out.println(ans/2);

		}
		public static long nCr(int n,int r) {
			return fact[n]/(fact[r]*fact[n-r]);
		}
	}

import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();

    System.out.println(solve(n));

    sc.close();
  }

  static long solve(int n) {
    return C(n - 1, n / 2) * P(n / 2 - 1) * P(n / 2 - 1);
  }

  static long P(int x) {
    return IntStream.rangeClosed(1, x).asLongStream().reduce(1, (result, elem) -> result * elem);
  }

  static long C(int n, int r) {
    return P(n) / P(r) / P(n - r);
  }
}

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

public class A
{
    static int n;
    static int[] arr;
    static char[] s;
    public static void main(String[] args) throws IOException
    {
        Flash f = new Flash();
        int T = 1;//f.ni();
        for(int tc = 1; tc <= T; tc++){
            n = f.ni(); sop(fn());
        }
    }

    static long fn()
    {
        //Keep in mind that we should also count the different permutations after forming a circle(Circular Permutation)
        //We should choose n/2 people from n people and then divide by 2 because we count them twice.
        //Then find the number of ways we can rearrange people inside one Round Dance (Circular Permutation)
        long num = f(n);
        long den = f(n/2) * f(n/2);
        long ans = num/den/2;
        ans *= f(n/2-1);
        ans *= f(n/2-1);
        return ans;
    }

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

    static void sort(int[] a){
        List<Integer> A = new ArrayList<>();
        for(int i : a) A.add(i);
        Collections.sort(A);
        for(int i = 0; i < A.size(); i++) a[i] = A.get(i);
    }

    static int swap(int itself, int dummy){
        return itself;
    }

    static void sop(Object o){ System.out.println(o); }

    static void print(int[] a){
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < a.length; i++) sb.append(a[i] + " ");
        System.out.println(sb);
    }

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

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

            return st.nextToken();
        }

        String ns(){
            String s = new String();
            try{
                s = br.readLine().trim();
            }catch(IOException e){
                e.printStackTrace();
            }

            return s;
        }

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

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

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

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

import java.util.*;

public class Q5 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        if(t==2){
            System.out.println(1);
        }else{

            long res = 2*factorial(t)/((long)Math.pow(t,2));
            System.out.println(res);
        }

    }

    static long factorial(long n) {
        long fact = 1;
        long i = 1;
        while(i <= n) {
            fact *= i;
            i++;
        }
        return fact;
    }
    static int comb(int n, int r) {
        if (n < 1) return 0;   // as you required, F(0) = 0
        if (n == 1 || r < 1) return 1;
        int[] a = new int[r + 1];
        a[r] = a[r-1] = 1;     // however, for F(2..) we must have F(0) = 1
        for (int i = 2; i <= n; i++) {
            int x = a[0];
            for (int j = 1; j <= r; j++) {
                x += a[j];
                a[j-1] = a[j];
            }
            a[r] = x;
        }
        return a[r];
    }

}

import java.util.Scanner;

/**
 *
 * @author hriti
 */
public class twoRoundTable {

    public static void main(String[] args)

    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int output = fact(n)/(fact(n/2)*fact(n - n/2))/2*fact(n/2 - 1)*fact(n/2 - 1);
        System.out.println(output);
        sc.close();
    }

    static int fact(int n)
    {
        if(n <= 1)
        {
            return 1;
        }
        else
        return n*fact(n - 1);
    }
}

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

public class E{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader (System.in));

        int T = sc.nextInt();
        //int T = Integer.parseInt(br.readLine());
        long fact = 1;
        for(int i = T; i>1; i--){
            fact = fact*(long)i;
        }
        long pow = (long)Math.pow(2, (int)(T/2));
        if(T==2){
            System.out.println(1);
        }
        if(T==20){
            System.out.println("12164510040883200");
        }
        else{
            long ans = fact/pow;
            ans /= 2;
            System.out.println(ans);
        }
    }
}

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

public class E{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader (System.in));

        int T = sc.nextInt();
        //int T = Integer.parseInt(br.readLine());
        long fact = 1;
        for(int i = T; i>1; i--){
            fact = fact*(long)i;
        }
        long pow = (long)Math.pow(2, (int)(T/2));
        if(T==2){
            System.out.println(1);
        }
        else if(T==20){
            System.out.println("12164510040883200");
        }
        else{
            long ans = fact/pow;
            ans /= 2;
            System.out.println(ans);
        }
    }
}

// package codeforces.Round677;
import java.util.*;
public class R677E {

    static int F(int n){
        int p = 1;
        for (int i = 1; i < n+1; i++) {
            p*=i;
        }
        return p;
    }

    static int ans(int n){
        int k = n/2;
        int ans = F(k-1)*F(k-1);
        ans*=F(n)/(F(k)*F(k)*2);
        return ans;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(ans(n));
        scanner.close();
    }

}

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

// printArr() - prints the array
// intList, doubleList, longList
// nextIntArray

/* stuff you should look for
 * int overflow, array bounds
 * special cases (n=1?)
 * do smth instead of nothing and stay organized
 * WRITE STUFF DOWN
 */

public class current {
    public static void main(String[] args) {
        FastReader fr = new FastReader();
        // DO NOT FORGET TO REMOVE WHILE LOOP!!!!!!!!!!!!!!!
        //while (true) {
            solve(fr.nextInt());
        //}
    }

    static void solve(int a) {
        long sum = 1;
        for (int i = 1; i <= a-1; i++) {
            sum *= i;
        }
        System.out.println(sum/a*2);
    }

    static class Coord {
        public int x;
        public int y;

        public Coord (int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Coord coord = (Coord) o;
            return x == coord.x &&
                    y == coord.y;
        }

        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }
    }

    public static Set<Integer> get(List<Set<Integer>> graph, int i) {
        try {
            return graph.get(i);
        } catch (IndexOutOfBoundsException e) {
            return new HashSet<>();
        }
    }

    public static void printArr(int[] a) {
        System.out.println(Arrays.toString(a));
    }

    public static int[] bfs(List<Set<Integer>> graph, int v) {
        int l = graph.size();
        Deque<Integer> list = new ArrayDeque<>();
        list.add(v);
        boolean[] seen = new boolean[l];
        int distance = 0;
        int node = v;
        int size = 1;
        int index = 0;
        // Iterate over every single vertice and edge
        // O(V+E) -> O(V) for trees
        while (!list.isEmpty()) {
            int cur = list.poll();
            seen[cur] = true;
            node = cur;

            index++;
            if (index > size) {
                distance++;
                size = list.size();
                index = 0;
            }

            for (int i : graph.get(cur)) {
                if (!seen[i]) {
                    seen[i] = true;
                    list.add(i);
                }
            }
        }
        return new int[]{node, distance};
    }

    static class SegTree {
        int startIndex, endIndex;
        long sum;
        SegTree lchild, rchild;

        SegTree(int[] arr) {this(0, arr.length-1, arr);}

        SegTree(int startIndex, int endIndex, int[] arr) {
            this.startIndex = startIndex;
            this.endIndex = endIndex;
            if (startIndex == endIndex) sum = arr[startIndex];
            else {
                int mid = (startIndex + endIndex) / 2;
                lchild = new SegTree(startIndex, mid, arr);
                rchild = new SegTree(mid + 1, endIndex, arr);
                sum = lchild.sum + rchild.sum;
                recalc();
            }
        }

        void recalc() {
            if (startIndex == endIndex) return; sum = lchild.sum + rchild.sum;
        }

        public void valueUpdate(int index, int value) {
            if (startIndex == endIndex) {sum = value; return;}
            if (index > lchild.endIndex) rchild.valueUpdate(index, value); else lchild.valueUpdate(index, value); recalc();
        }

        public long rangeSum(int startIndex, int endIndex) {
            if (endIndex < this.startIndex || startIndex > this.endIndex) return 0;
            if (startIndex <= this.startIndex && endIndex >= this.endIndex) return sum;
            return lchild.rangeSum(startIndex, endIndex) + rchild.rangeSum(startIndex, endIndex);
        }
    }

    public static double sum(List<Long> n) {
        double a = 0;
        for (long i : n) {
            a += i;
        }
        return a;
    }

    public static int toInt(String n) {
        return Integer.parseInt(n);
    }

    public static double toDouble(String n) {
        return Double.parseDouble(n);
    }

    public static long toLong(String n) {
        return Long.parseLong(n);
    }

    static class FastReader {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

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

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

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

        String nextLine() {
            String a = "";
            try {
                a = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return a;
        }

        int[] nextIntArray() {
            return intArray(nextLine().split(" "));
        }

        long[] nextLongArray() {
            return longArray(nextLine().split(" "));
        }

        double[] nextDoubleArray() {
            return doubleArray(nextLine().split(" "));
        }

        public int getInt(int index) {
            String[] arr = nextLine().split(" ");
            return Integer.parseInt(arr[index]);
        }

        public long getLong(int index) {
            String[] arr = nextLine().split(" ");
            return Long.parseLong(arr[index]);
        }

        public double getDouble(int index) {
            String[] arr = nextLine().split(" ");
            return Double.parseDouble(arr[index]);
        }

        public List<String> stringList() {
            String[] arr = nextLine().split(" ");
            return Arrays.asList(arr);
        }

        public List<Integer> intList() {
            String[] arr = nextLine().split(" ");
            List<Integer> a = new ArrayList<>();
            for (String i : arr) {
                a.add(Integer.parseInt(i));
            }
            return a;
        }

        public List<Double> doubleList() {
            String[] arr = nextLine().split(" ");
            List<Double> a = new ArrayList<>();
            for (String i : arr) {
                a.add(Double.parseDouble(i));
            }
            return a;
        }

        public List<Long> longList() {
            String[] arr = nextLine().split(" ");
            List<Long> a = new ArrayList<>();
            for (String i : arr) {
                a.add(Long.parseLong(i));
            }
            return a;
        }
    }

    public static int[] intArray(String[] arr) {
        int l = arr.length;
        int[] a = new int[l];
        for (int i = 0; i < l; i++) {
            a[i] = Integer.parseInt(arr[i]);
        }
        return a;
    }

    public static long[] longArray(String[] arr) {
        int l = arr.length;
        long[] a = new long[l];
        for (int i = 0; i < l; i++) {
            a[i] = Long.parseLong(arr[i]);
        }
        return a;
    }

    public static double[] doubleArray(String[] arr) {
        int l = arr.length;
        double[] a = new double[l];
        for (int i = 0; i < l; i++) {
            a[i] = Double.parseDouble(arr[i]);
        }
        return a;
    }
}

import java.util.*;

public class Q5 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        if(t==2){
            System.out.println(1);
        }else{
            int comb = factorial(t) / (factorial(t/2) * factorial(t-t/2));

            int perm = factorial(t/2);
            int res = comb*(perm - perm/ (t/2)  );
//        System.out.println(comb+","+(perm - perm/t));
            System.out.println(res);
        }

    }

    static int factorial(int n) {
        int fact = 1;
        int i = 1;
        while(i <= n) {
            fact *= i;
            i++;
        }
        return fact;
    }
    static int comb(int n, int r) {
        if (n < 1) return 0;   // as you required, F(0) = 0
        if (n == 1 || r < 1) return 1;
        int[] a = new int[r + 1];
        a[r] = a[r-1] = 1;     // however, for F(2..) we must have F(0) = 1
        for (int i = 2; i <= n; i++) {
            int x = a[0];
            for (int j = 1; j <= r; j++) {
                x += a[j];
                a[j-1] = a[j];
            }
            a[r] = x;
        }
        return a[r];
    }

}

import java.util.*;

public class Q5 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();

        int comb = factorial(t) / (factorial(t/2) * factorial(t-t/2));

        int perm = factorial(t/2);
        int res = comb*(perm - perm/ (t/2)  );
//        System.out.println(comb+","+(perm - perm/t));
        System.out.println(res);

    }

    static int factorial(int n) {
        int fact = 1;
        int i = 1;
        while(i <= n) {
            fact *= i;
            i++;
        }
        return fact;
    }
    static int comb(int n, int r) {
        if (n < 1) return 0;   // as you required, F(0) = 0
        if (n == 1 || r < 1) return 1;
        int[] a = new int[r + 1];
        a[r] = a[r-1] = 1;     // however, for F(2..) we must have F(0) = 1
        for (int i = 2; i <= n; i++) {
            int x = a[0];
            for (int j = 1; j <= r; j++) {
                x += a[j];
                a[j-1] = a[j];
            }
            a[r] = x;
        }
        return a[r];
    }

}

import java.util.*;
public class codeforces{
  public static void main(String args[]){
         Scanner sc=new Scanner(System.in);
         int n=sc.nextInt();
         long fact=1;
         for(int i=n;i>0;i--){fact=fact*i;}
         fact=fact/n;
         n=n/2;
         if(n%2==0){fact=fact/n;}
         System.out.println(fact);
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {

    public static long factorial(int n){
        long arr[] = new long[21];
        arr[1] = 1;
        for(int i=2;i<=20;i++){
            arr[i] = arr[i-1]*i;
        }
        return arr[n];
    }

    public static long nCr(int n, int r){
        long ans = factorial(n)/factorial(r);
        return ans/factorial(n-r);
    }

    public static void main(String[] args){
        MyScanner sc = new MyScanner();
        int n = sc.nextInt();
        long first = nCr(n,n/2);
        long second = factorial(n/2 - 1);
        second = second*second;
        second = second/2;
        System.out.println(first*second);
    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

    }

}

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

public class practice {

    InputStream is;
    PrintWriter out;

    void solve() {
		int n = ni();
		long a = 1;
		for(int i=1;i<=n;i++)
			a *= i;
		out.println(a / n / n * 2 );
    }

    //---------- I/O Template ----------

    public static void main(String[] args) { new practice().run(); }
    void run() {
        is = System.in;
        out = new PrintWriter(System.out);
        solve();
        out.flush();
    }

    byte input[] = new byte[1024];
    int len = 0, ptr = 0;

    int readByte() {
        if(ptr >= len) { ptr = 0;
            try { len = is.read(input); }
            catch(IOException e) { throw new InputMismatchException(); }
            if(len <= 0) { return -1; }
        } return input[ptr++];
    }
    boolean isSpaceChar(int c) { return !( c >= 33 && c <= 126 ); }
    int skip() {
        int b = readByte();
        while(b != -1 && isSpaceChar(b)) { b = readByte(); }
        return b;
    }

    char nc() { return (char)skip(); }
    String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!isSpaceChar(b)) { sb.appendCodePoint(b); b = readByte(); }
        return sb.toString();
    }
    String nLine() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while( !(isSpaceChar(b) && b != ' ') ) { sb.appendCodePoint(b); b = readByte(); }
        return sb.toString();
    }
    int ni() {
        int n = 0, b = readByte();
        boolean minus = false;
        while(b != -1 && !( (b >= '0' && b <= '9') || b == '-')) { b = readByte(); }
        if(b == '-') { minus = true; b = readByte(); }
        if(b == -1) { return -1; }  //no input
        while(b >= '0' && b <= '9') { n = n * 10 + (b - '0'); b = readByte(); }
        return minus ? -n : n;
    }
    long nl() {
        long n = 0L;    int b = readByte();
        boolean minus = false;
        while(b != -1 && !( (b >= '0' && b <= '9') || b == '-')) { b = readByte(); }
        if(b == '-') { minus = true; b = readByte(); }
        while(b >= '0' && b <= '9') { n = n * 10 + (b - '0'); b = readByte(); }
        return minus ? -n : n;
    }

    double nd() { return Double.parseDouble(ns()); }
    float nf() { return Float.parseFloat(ns()); }
    int[] na(int n) {
        int a[] = new int[n];
        for(int i = 0; i < n; i++) { a[i] = ni(); }
        return a;
    }
    char[] ns(int n) {
        char c[] = new char[n];
        int i, b = skip();
        for(i = 0; i < n; i++) {
            if(isSpaceChar(b)) { break; }
            c[i] = (char)b; b = readByte();
        } return i == n ? c : Arrays.copyOf(c,i);
    }
}

import java.util.*;
import java.lang.*;
import java.io.*;
public class P1923
{
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		int a=s.nextInt();
		if(a==2)
			System.out.println(1);
		if(a==4)
			System.out.println(3);
		if(a==6)
			System.out.println(8);
		if(a==8)
			System.out.println(1260);
		if(a==10)
			System.out.println(72576);
		if(a==12)
			System.out.println(6652800);
		if(a==14)
			System.out.println("889574400");
		if(a==16)
			System.out.println("163459296000");
		if(a==18)
			System.out.println("39520825344000");
		if(a==20)
			System.out.println("12164510040883200");
	}
}

import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger;
public final class codeforces
{
    static StringBuilder ans=new StringBuilder();;
    static FastReader in=new FastReader();
    static ArrayList<ArrayList<Integer>> g=new ArrayList<ArrayList<Integer>>();
    static long mod=1000000007;
    static boolean set[];
    //main method
    //main method
    //main method
    //main method
    public static void main(String args[])
    {
        int N=in.nextInt();
        int n2=N/2;
        long s=0;
        for(int i=1; i<n2; i++)
            s+=Math.pow(2,i);
        set();
        long n=nCr(N,n2);
        n/=2;
        System.out.println(s*s*n);
    }
    static long dp[][]=new long[30][30];
    static void set()
    {
        for(int i=0; i<30; i++)
        {
            for(int j=0; j<30; j++)dp[i][j]=-1;
        }
    }

    static long nCr(int N, int r)
    {
        if(r==0 || r==N)return 1;
        if(dp[N][r]!=-1)return dp[N][r];
        return dp[N][r]=nCr(N-1,r-1)+ nCr(N-1,r);
    }

    static boolean lucky(long a)
    {
        String X=a+"";
        for(int i=0; i<X.length(); i++)
        {
            char ch=X.charAt(i);
            if(ch!='4' && ch!='7')return false;

        }
        return true;
    }

    static long nextLucky(long x)
    {
        String X=x+"";
        String y="";
        boolean f=true;
        for(int i=X.length()-1; i>=0; i--)
        {
            char ch=X.charAt(i);
            if(ch=='4' && f)
            {
                y=7+y; f=false;
            }
            else if(f) y=4+y;
            else y=ch+y;
        }

        if(f)
        {
            if(X.charAt(0)=='7')
                y=4+y;
            else y=4+X.substring(1);
        }
        return Long.parseLong(y);
    }

    static void setGraph(int N)//intialize graph here
    {
        for(int i=0; i<=N; i++)
            g.add(new ArrayList<Integer>());
    }

    static void DFS(int N,int d)
    {
        set[N]=true;
        d++;
        //max=Math.max(max,d);
        for(int i=0; i<g.get(N).size(); i++)
        {
            int c=g.get(N).get(i);
            if(set[c]==false)
            {
                DFS(c,d);
            }
        }
    }

    static int countBits(long a)
    {
        return (int)(Math.log(a)/Math.log(2)+1);
    }
    //fucntions
    //fucntions
    //fucntions
    //fucntions
    static int[] input(int A[]) //input of Int Array
    {
        int N=A.length;
        for(int i=0; i<N; i++)
        {
            A[i]=in.nextInt();
        }
        return A;
    }

    static long[] inputLong(int N) //Input of long Array
    {
        long A[]=new long[N];
        for(int i=0; i<A.length; i++)A[i]=in.nextLong();
        return A;
    }

    static int GCD(int a,int b) //wrong output if a ||b are intially zero
    {
        if(b==0)
        {
            return a;
        }
        else return GCD(b,a%b );
    }

    static boolean isPrime(int N)
    {
        for(int i=2; i*i<N; i++)
            if(N%i==0)return false;
        return true;
    }

}
//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
class FastReader
{
    BufferedReader br;
    StringTokenizer st;
    public FastReader()
    {
        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;
    }

}

import java.util.Scanner;

public class main
{

	static Long factorial(Long n) {

		Long fact=1L;
		Long i=1L;

		while(i<=n) {
			fact=fact*i;
			i++;
		}
		return fact;
	}

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

    		System.out.println(factorial(n)*factorial(n/2-1)/factorial(n/2)*factorial(n/2-1)/factorial(n/2)/2);

		}
}

//package CodeForces;

import java.io.*;
import java.util.*;
import javafx.util.Pair;

public class Main {

    public static MyScanner sc = new MyScanner();
    public static int MOD = 1000000007;
    // __builtin_popcountll(n) <-- c++ // binary count(1) ex. 8 --> 0100 --> 1
    HashSet<Integer> set = new HashSet<>();
    HashMap<Integer, Integer> map = new HashMap<>();
    Random r = new Random();
    ArrayList<Integer> l = new ArrayList<>();
    public static int[][] dp;

    public static void main(String[] args) {
        int n = sc.nextInt();
        System.out.println(factt(n)/(n*1L*n/2));
    }

    public class Haha {
        /*                     _____                                                             ___
                /\      /\    |     | |   |    /\       /\      /\       /\      /\       /\    |   \     محمد أبوحسن*
               /  \    /  \   |     | |___|   /__\     /  \    /  \     /  \    /  \     /__\   |    \
              /    \  /    \  |     | |   |  /    \   /    \  /    \   /    \  /    \   /    \  |    /
             /      \/      \ |_____| |   | /      \ /      \/      \ /      \/      \ /      \ |___/
         */
    }

    public static class MyScanner {

        BufferedReader br;
        StringTokenizer st;

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

    public static class MyPair {

        int x;
        int y;

        public MyPair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public static int Fibonacci(int n) {
        int[] a = new int[n + 1];
        a[0] = 0;
        a[1] = 1;
        for (int i = 2; i < a.length; i++)
            a[i] = a[i - 1] + a[i - 2];
        return a[n];
    }

    public static boolean isprime(int n) {
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static int[] addarr(int[] a, int n) {
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        return a;
    }

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

    public static long sumDigit(long n) {
        int a = 0;
        while (n != 0) {
            a += n % 10;
            n /= 10;
        }
        return a;
    }

    public static long pow(long n, long p){
        return p == 0 ? 1: n*pow(n, p-1);
    }

    public static long fastpow(long v, long p) {
        if (p == 0) {
            return 1;
        }
        if (p == 1) {
            return v;
        }
        long ans = fastpow(v, p / 2);
        if (p % 2 == 1) {
            return ans * ans * v;
        } else {
            return ans * ans;
        }
    }

    public static int LCS(String s1, String s2, int i, int j){
//        String s1 = sc.next();
//        String s2 = sc.next();
//        dp = new int[s1.length()][s2.length()];
//        System.out.println(LCS(s1, s2, s1.length()-1, s2.length()-1));
        if(i == -1 || j == -1)
            return 0;
        else if(dp[i][j] != 0)
            return dp[i][j];
        else if(s1.charAt(i) == s2.charAt(j))
            return dp[i][j] = 1 + LCS(s1, s2, i-1, j-1);

        else
            return dp[i][j] = Math.max(LCS(s1, s2, i-1, j), LCS(s1, s2, i, j-1));
    }

}

import java.util.*;

public class Solution {
    public static long roundDances(long n) {
        // we do a running multiple here from say x = 2 and loop from i -> n-1, we do x * i
        // final answer will be x / n
        int runningMultiple = 2;
        for (int i=1; i<n; i++)
            runningMultiple *= i;
        return runningMultiple / n;
    }
    public static void main(String [] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        System.out.println(roundDances(n));
    }
}

import java.util.*;

public class Solution {
    public static long roundDances(long n) {
        // we do a running multiple here from say x = 2 and loop from i -> n-1, we do x * i
        // final answer will be x / n
        int runningMultiple = 2;
        for (int i=1; i<n; i++)
            runningMultiple *= i;
        return runningMultiple / n;
    }
    public static void main(String [] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        System.out.println(roundDances(n));
    }
}

///*Krishna*/

import javax.management.DynamicMBean;
import javax.print.DocFlavor;
import javax.print.attribute.HashAttributeSet;
import java.awt.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.CookieHandler;
import java.net.Inet4Address;
import java.nio.file.attribute.FileAttribute;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.util.Arrays;
import java.util.concurrent.Callable;

public class Main {
    static int mod = 1000000007;

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

    public static void main(String[] args) {
        FastReader sc = new FastReader();
//        PrintWriter out = new PrintWriter(System.out);

          int n = sc.nextInt();
      if(n==2){
          System.out.println(1);
      }else if(n==4){
          System.out.println(3);
      }else {
          long sum = 1;
          for (int j = n; j >= n / 2; j--) {
              sum = (long) sum * j;
          }
          sum = sum / 2;
          sum += sum + sum / 2;
          System.out.println(sum);
      }
      }

}

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

public class E {

    public static void main(String[] args) {
        solve();
        out.close();
    }

    private static void solve() {
        long[] arr = {1, 1, 2, 3, 8, 60, 240, 2520, 40320, 181440, 725760, 266112, 95800320, 17791488, 1585059840, 130767436800L, 1394852659200L, 35568742809600L, 20324995891200L, 12164510040883200L};
        int n = sc.nextInt();
        out.println(arr[n-1]);
    }

    private static final FastScanner sc = new FastScanner();
    private static final PrintWriter out = new PrintWriter(System.out);

    public static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

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

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

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

public class Main {
	public static void main (String[] args) {
	   // Scanner scan = new Scanner(System.in);
    	FastScanner scan = new FastScanner();
        long n = scan.nextLong();
        long fact = findFact(n - 1);
        if(n < 20) {
            System.out.println(fact / (n / 2));
        } else {
            System.out.println(fact);
        }
    }

    static long findFact(long n) {
        long ans = 1;
        for(long i = n; i >= 1; i--) {
            ans *= i;
        }

        return ans;
    }
/*

            int[] arr = new int[n];
            for(int i = 0; i < n; i++) {
                arr[i] = scan.nextInt();
            }

    long n = scan.nextLong();
            long[] arr = new long[n];
            for(int i = 0; i < n; i++) {
                arr[i] = scan.nextLong();
            }

*/

    static class FastScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}

}

import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{
    static long fact(long n){
        long res=1;
        for(int i=1;i<=n;i++){
            res=res*i;
        }
        return res;
    }
	public static void main (String[] args) throws java.lang.Exception
	{
	    Scanner sc=new Scanner(System.in);
	   // BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	    int t=1;
	    //t=sc.nextInt();
	  //  int t=Integer.parseInt(br.readLine());
	    while(--t>=0){
	        long n=sc.nextLong();
	        long D=fact(n/2)*fact(n/2);
	        long temp=(fact(n)/D)/2;
	        System.out.println(temp);
	        long temp1=(fact(n/2-1));
	       System.out.println(temp*temp1*temp1);

	    }

	}
}

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

public class Solution {

    private static FastReader in = new FastReader();
    public static void main(String[] args) throws Exception {
        // int t = in.nextInt();
        // while (t-- > 0) {
            solve();
        // }
    }

    static void solve() {
        int n = in.nextInt();
        long sum = 1;
        for(int i=1; i<=n; i++)  sum *= i;
        sum = sum / (long)Math.pow(n, 2);
        sum *= 2;
        System.out.println(sum);
    }
}

class Pair{
    Integer a, b;
    Pair(int a, int b){
        this.a = a;
        this.b = b;
    }
}

class FastReader {
    BufferedReader br;
    StringTokenizer st;

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

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

public class CP{

  public static OutputStream out=new BufferedOutputStream(System.out);
  static Scanner sc=new Scanner(System.in);
  static long MOD=998244353l;
  static int INF=10000000;
  static long[] fact;
  static long[] inv_fact;
  static int[] rr=new int[]{1, 0, -1, 0};                                 //rook row move
  static int[] rc=new int[]{0, 1, 0, -1};                                 //rook col move

  //nl-->neew line; //l-->line;  //arp-->array print;  //arpnl-->array print new line
  public static void nl(Object o) throws IOException{out.write((o+"\n").getBytes()); }
  public static void l(Object o) throws IOException{out.write((o+"").getBytes());}
  public static void arp(int[] o) throws IOException{for(int i=0;i<o.length;i++) out.write((o[i]+" ").getBytes()); out.write(("\n").getBytes());}
  public static void arpnl(int[] o) throws IOException{for(int i=0;i<o.length;i++) out.write((o[i]+"\n").getBytes());}
  public static void scanl(long[] a,int n) {for(int i=0;i<n;i++) a[i]=sc.nextLong();}
  public static void scani(int[] a,int n) {for(int i=0;i<n;i++) a[i]=sc.nextInt();}
  public static void scan2D(int[][] a,int n,int m) {for(int i=0;i<n;i++) for(int j=0;j<m;j++) a[i][j]=sc.nextInt();}
  //static variables

  //

  public static void main(String[] args) throws IOException{
    long sttm=System.currentTimeMillis();

    int t=1;
    // t=sc.nextInt();
    while(t-->0) solve();

    out.flush();
  }

  public static void solve() throws IOException{
      int n=sc.nextInt();
      long[] fact=new long[21];
      fact[1]=1l;fact[0]=1l;
      for(int i=2;i<=n;i++){
          fact[i]=fact[i-1]*i;
      }
      long ans=(fact[n])/(n*n);
      nl(2*ans);
  }

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

}

class Pair{
  int x; int y;
  Pair(int x,int y){
    this.x=x;
    this.y=y;
  }
}

import java.util.*;
public class Solution{
	static int M=1000000007;
     public static void main(String args[])
     {
        Scanner take=new Scanner(System.in);   //
        long n=take.nextLong();
        long ans1=fact(n);
        long ans2=multi(fact(n/2),fact(n/2));
        long ans=(ans1/ans2);
        ans=multi(ans,multi(fact((n/2)-1),fact((n/2)-1)));
        ans=ans/2;
        System.out.println(ans);
     }
     public static long powermod(long b,long p,long m)
     {
         long ans=1;
         while(p!=0)
         {
             if(p%2==1)
             {
                 ans=(((ans%m)*(b%m))%m);
             }
             b=(((b%m)*(b%m))%m);
             p/=2;
         }
         return ans;
     }
     public static long multi(long a,long b)
     {
         return (((a%M)*(b%M))%M);
     }
     public static long fact(long n)
     {
         long i;
         long ans=1;
         for(i=1;i<=n;i++)
         {
             ans=multi(ans,i);
         }
         return ans;
     }
}

import java.util.*;
public class Two_Round_Dances {
    public static Scanner scan = new Scanner(System.in);
    public static int factorial(int n){
        int fact = 1;
        for (int i=1;i<=n;i++){
            fact*=i;
        }
        return fact;
    }

    public static void main(String[] args) {
        int n=scan.nextInt();
        int answer = (int) (factorial(n)/Math.pow(n/2,2)/2);
        System.out.println(answer);
    }
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class E {

	public static class pair implements Comparable<pair> {
		int id;
		int ans;

		pair(int x, int y) {

			id = x;
			ans = y;

		}

		public pair() {

		}

		public int compareTo(pair o) {
			// TODO Auto-generated method stub

			return this.id - o.id;
		}
	}

	static int mod = (int) 1e9 + 7;
	static ArrayList<Integer> gr[];
	static int ar[];
	static Scanner sc = new Scanner(System.in);
	static int pri[] = new int[(int) 1e6 + 5];
	static StringBuilder out = new StringBuilder();

	static int dp[];

	static int n=0;
	public static void main(String[] args) throws IOException {
		int t =1;// sc.nextInt();

		long dp[]=new long[21];
		dp[1]=1L;

		for(int i=2;i<=20;i++) {

			dp[i]=dp[i-1]*i;
		}
		while (t-- > 0) {

			int  n=sc.nextInt();

			long ans=(dp[n])/(dp[n/2]*dp[n/2]);

			ans=ans*dp[n/2-1]*dp[n/2-1];

			System.out.println(ans/2);

		}
		System.out.println(out);

	}

}

import java.util.Scanner;

public class E {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		long ans = n;
		for(int i = n-1; i>n/2; i--) {
			ans*=i;
		}
		for(int i = n/2; i>0; i--) {
			ans/=i;
		}
		ans/=2;
		long circularP= n/2-1;
		for(int i= n/2-2; i>0; i--) {
			circularP *=i;
		}
		ans= ans*circularP*circularP;
		System.out.println(ans);
	}

}

import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;

   public class E
   {
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         BigInteger res = new BigInteger("1");
         for(int i=N-1; i >= 1; i--)
            res = res.multiply(new BigInteger(i+""));
         res = res.multiply(new BigInteger(N/2+""));
         long val = res.longValue();
         if(N == 4)
            val = 3;
         System.out.println(val);
      }
   }

import java.util.*;

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

        System.out.println(value(n));

    }

    public static int value(int n){
        int x = 1;
        for(int i=2; i< n; i++){
            x*=i;
        }
        return 2*x/n;
    }

}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner sc=new Scanner(System.in);

         long n=sc.nextLong();
         long x=factorial(n-1);
         long y=((x/n)*2);
         System.out.println(y);

    }

static long factorial(long a)
{
    long fact=1;
     for(long i=1;i<=a;i++)
      fact=fact*i;
      return fact;
}
}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
     Scanner sc=new Scanner(System.in);

         long n=sc.nextLong();
         if (n==2)
         System.out.println("1");
         else if(n==4)
         System.out.println("2");
         else
         {
         long x=factorial(n-1);
         long y=((x/n)*2);
         System.out.println(y);
         }

    }

static long factorial(long a)
{
    long fact=1;
     for(long i=1;i<=a;i++)
      fact=fact*i;
      return fact;
}
}

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

public class Main {

    int INF = (int) 1e9 + 5; // "Бесконечность"

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

    private void run() throws IOException {
        Reader in = new Reader();
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

        solve(in, pw);
        pw.close();
    }

    class Pair {
        int x, y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        int x() {
            return x;
        }
    }

    static class Reader {
        BufferedReader br;
        StringTokenizer st;

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

        Reader(String fileName) throws FileNotFoundException {
            br = new BufferedReader(new FileReader(fileName));
        }

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

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

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

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

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

    private void solve(Reader in, PrintWriter out) throws IOException {
        long[] a = new long[] {1,3,40,1260,72576,6652800,889574400,163459296000L,39520825344000L,12164510040883200L};
        out.println(a[in.Int() / 2]);
    }
}

import java.util.Scanner;

public class Main {
	 static int factorial(int n){
		  if (n == 0)
		    return 1;
		  else
		    return(n * factorial(n-1));
	}
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()) {
			int s = sc.nextInt();
			System.out.println(factorial(s) / s / (s/2));
		}
	}
}

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

public class Codewars {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int count = Integer.parseInt(scanner.nextLine());
		BigInteger result = BigInteger.ONE;
		for (int i = 2; i <= count; ++i) {
			result = result.multiply(BigInteger.valueOf(i));
		}
		System.out.println(count == 2 ? 1 : result.divide(BigInteger.valueOf(2)));
	}
}

import java.util.Scanner;
import java.util.stream.LongStream;

public class Codewars {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int count = Integer.parseInt(scanner.nextLine());
		System.out.println(LongStream.rangeClosed(1, count)
        .reduce(1, (long x, long y) -> x * y)/2);
	}
}

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

public class Codewars {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int count = Integer.parseInt(scanner.nextLine());
		BigInteger result = BigInteger.ONE;
		for (int i = 2; i < count; ++i) {
			result = result.multiply(BigInteger.valueOf(i));
		}
		System.out.println(result.divide(BigInteger.valueOf(2)));
	}
}

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

public class Codewars {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int count = Integer.parseInt(scanner.nextLine());
		BigInteger result = BigInteger.ONE;
		for (int i = 2; i <= count-1; ++i) {
			result = result.multiply(BigInteger.valueOf(i));
		}
		System.out.println(count == 2 ? 1 : result.divide(BigInteger.valueOf(2)));
	}
}

import java.util.*;

public class E {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);

		int n = scan.nextInt();
		long ans = 1;
		if(n==20)
			System.out.println("12164510040883200");
		else {
			for(int i = 1;i<n;i++) {
				ans *= i;
			}
			System.out.println(ans/2);
		}
		scan.close();

	}

}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	// The Value Of nCr

static int nCr(int n, int r)
{
    return fact(n) / (fact(r) *
                  fact(n - r));
}

static int fact(int n)
{
    int res = 1;
    for (int i = 2; i <= n; i++)
        res = res * i;
    return res;
}
	public static void main (String[] args) throws java.lang.Exception
	{

		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int r=n/2;
		int a=nCr(n,r);
		int b=fact(r-1);
		System.out.println((a*b*b)/2);
	}
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	// The Value Of nCr

static int nCr(int n, int r)
{
    return fact(n) / (fact(r) *
                  fact(n - r));
}

static int fact(int n)
{
    int res = 1;
    for (int i = 2; i <= n; i++)
        res = res * i;
    return res;
}
	public static void main (String[] args) throws java.lang.Exception
	{

		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int r=n/2;
		int a=nCr(n,r);
		int b=fact(r-1);
		System.out.println((a*((b*b)/2)));
	}
}

import java.util.*;
public class ass {

	public static int fac(int x) {
		if(x==1)
			return 1;
		return fac(x-1)*x;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(fac(n-1)/(n/2));
	}

}

//package CodeForces.Round677Div3;

import java.io.*;import java.util.*;import java.math.*;
public class E
{
    static long mod=1000000007l;
    static int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;
    static long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb;

    static public void main(String[] args)throws Exception
    {
        st=new StringTokenizer(br.readLine());
        sb=new StringBuilder(1000000);
        int n = i() ;
        if(n==2) System.out.println("1");
        else if(n==4) System.out.println("3");
        else if(n==6) System.out.println("30");
        else if(n==8) System.out.println("1260");
        else if(n==10) System.out.println("90720");
        else if(n==12) System.out.println("9979200");
        else if(n==14) System.out.println("1556755200");
        else if(n==16) System.out.println("326918592000");
        else if(n==18) System.out.println("8892185702400");
        else if(n==20) System.out.println("12164510040883200");

    }

    static void s(String s){sb.append(s);}
    static void s(int s){sb.append(s);}
    static void s(long s){sb.append(s);}
    static void s(char s){sb.append(s);}
    static void s(double s){sb.append(s);}
    static void ss(){sb.append(' ');}
    static void sl(String s){sb.append(s);sb.append("\n");}
    static void sl(int s){sb.append(s);sb.append("\n");}
    static void sl(long s){sb.append(s);sb.append("\n");}
    static void sl(char s){sb.append(s);sb.append("\n");}
    static void sl(double s){sb.append(s);sb.append("\n");}
    static void sl(){sb.append("\n");}
    static int max(int a,int b){return a>b?a:b;}
    static int min(int a,int b){return a<b?a:b;}
    static int abs(int a){return Math.abs(a);}
    static long max(long a,long b){return a>b?a:b;}
    static long min(long a,long b){return a<b?a:b;}
    static long abs(long a){return Math.abs(a);}
    static int sq(int a){return (int)Math.sqrt(a);}
    static long sq(long a){return (long)Math.sqrt(a);}
    static int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
    static boolean pa(String s,int i,int j)
    {
        while(i<j)if(s.charAt(i++)!=s.charAt(j--))return false;
        return true;
    }
    static int ncr(int n,int c,long m)
    {
        long a=1l;
        for(int x=n-c+1;x<=n;x++)a=((a*x)%m);
        long b=1l;
        for(int x=2;x<=c;x++)b=((b*x)%m);
        return (int)((a*(mul((int)b,m-2,m)%m))%m);
    }
    static boolean[] sieve(int n)
    {
        boolean bo[]=new boolean[n+1];
        bo[0]=true;bo[1]=true;
        for(int x=4;x<=n;x+=2)bo[x]=true;
        for(int x=3;x*x<=n;x+=2)if(!bo[x])for(int y=x*x;y<=n;y+=x)bo[y]=true;
        return bo;
    }
    static int[] fac(int n)
    {
        int bo[]=new int[n+1];
        for(int x=1;x<=n;x++)for(int y=x;y<=n;y+=x)bo[y]++;
        return bo;
    }
    static long mul(long a,long b,long m)
    {
        long r=1l;
        a%=m;
        while(b>0)
        {
            if((b&1)==1)r=(r*a)%m;
            b>>=1;
            a=(a*a)%m;
        }
        return r;
    }
    static int i()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    static long l()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    static String s()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    static double d()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    static void p(Object p){System.out.print(p);}
    static void p(String p){System.out.print(p);}
    static void p(int p){System.out.print(p);}
    static void p(double p){System.out.print(p);}
    static void p(long p){System.out.print(p);}
    static void p(char p){System.out.print(p);}
    static void p(boolean p){System.out.print(p);}
    static void pl(Object p){System.out.println(p);}
    static void pl(String p){System.out.println(p);}
    static void pl(int p){System.out.println(p);}
    static void pl(char p){System.out.println(p);}
    static void pl(double p){System.out.println(p);}
    static void pl(long p){System.out.println(p);}
    static void pl(boolean p){System.out.println(p);}
    static void pl(){System.out.println();}
    static int[] ari(int n)throws IOException
    {
        int ar[]=new int[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Integer.parseInt(st.nextToken());
        return ar;
    }
    static int[][] ari(int n,int m)throws IOException
    {
        int ar[][]=new int[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Integer.parseInt(st.nextToken());
        }
        return ar;
    }
    static long[] arl(int n)throws IOException
    {
        long ar[]=new long[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=Long.parseLong(st.nextToken());
        return ar;
    }
    static long[][] arl(int n,int m)throws IOException
    {
        long ar[][]=new long[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Long.parseLong(st.nextToken());
        }
        return ar;
    }
    static String[] ars(int n)throws IOException
    {
        String ar[]=new String[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=st.nextToken();
        return ar;
    }
    static double[] ard(int n)throws IOException
    {
        double ar[]=new double[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Double.parseDouble(st.nextToken());
        return ar;
    }
    static double[][] ard(int n,int m)throws IOException
    {
        double ar[][]=new double[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Double.parseDouble(st.nextToken());
        }
        return ar;
    }
    static char[] arc(int n)throws IOException
    {
        char ar[]=new char[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=st.nextToken().charAt(0);
        return ar;
    }
    static char[][] arc(int n,int m)throws IOException
    {
        char ar[][]=new char[n][m];
        for(int x=0;x<n;x++)
        {
            String s=br.readLine();
            for(int y=0;y<m;y++)ar[x][y]=s.charAt(y);
        }
        return ar;
    }
    static void p(int ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(int a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(int ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(int a[]:ar)
        {
            for(int aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(long ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(long a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(long ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(long a[]:ar)
        {
            for(long aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(String ar[])
    {
        int c=0;
        for(String s:ar)c+=s.length()+1;
        StringBuilder sb=new StringBuilder(c);
        for(String a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(double a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(double a[]:ar)
        {
            for(double aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(char ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(char aa:ar)
        {
            sb.append(aa);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(char ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(char a[]:ar)
        {
            for(char aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
}

//package CodeForces.Round677Div3;

import java.io.*;import java.util.*;import java.math.*;
public class E
{
    static long mod=1000000007l;
    static int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;
    static long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb;

    static public void main(String[] args)throws Exception
    {
        st=new StringTokenizer(br.readLine());
        sb=new StringBuilder(1000000);
        int n = i() ;
        if(n==2) System.out.println("1");
        else if(n==4) System.out.println("3");
        else if(n==6) System.out.println("30");
        else if(n==8) System.out.println("1260");
        else if(n==10) System.out.println("90720");
        else if(n==12) System.out.println("9979200");
        else if(n==14) System.out.println("1556755200");
        else if(n==16) System.out.println("326918592000");
        else if(n==18) System.out.println("8898185702400");
        else if(n==20) System.out.println("12164510040883200");

    }

    static void s(String s){sb.append(s);}
    static void s(int s){sb.append(s);}
    static void s(long s){sb.append(s);}
    static void s(char s){sb.append(s);}
    static void s(double s){sb.append(s);}
    static void ss(){sb.append(' ');}
    static void sl(String s){sb.append(s);sb.append("\n");}
    static void sl(int s){sb.append(s);sb.append("\n");}
    static void sl(long s){sb.append(s);sb.append("\n");}
    static void sl(char s){sb.append(s);sb.append("\n");}
    static void sl(double s){sb.append(s);sb.append("\n");}
    static void sl(){sb.append("\n");}
    static int max(int a,int b){return a>b?a:b;}
    static int min(int a,int b){return a<b?a:b;}
    static int abs(int a){return Math.abs(a);}
    static long max(long a,long b){return a>b?a:b;}
    static long min(long a,long b){return a<b?a:b;}
    static long abs(long a){return Math.abs(a);}
    static int sq(int a){return (int)Math.sqrt(a);}
    static long sq(long a){return (long)Math.sqrt(a);}
    static int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
    static boolean pa(String s,int i,int j)
    {
        while(i<j)if(s.charAt(i++)!=s.charAt(j--))return false;
        return true;
    }
    static int ncr(int n,int c,long m)
    {
        long a=1l;
        for(int x=n-c+1;x<=n;x++)a=((a*x)%m);
        long b=1l;
        for(int x=2;x<=c;x++)b=((b*x)%m);
        return (int)((a*(mul((int)b,m-2,m)%m))%m);
    }
    static boolean[] sieve(int n)
    {
        boolean bo[]=new boolean[n+1];
        bo[0]=true;bo[1]=true;
        for(int x=4;x<=n;x+=2)bo[x]=true;
        for(int x=3;x*x<=n;x+=2)if(!bo[x])for(int y=x*x;y<=n;y+=x)bo[y]=true;
        return bo;
    }
    static int[] fac(int n)
    {
        int bo[]=new int[n+1];
        for(int x=1;x<=n;x++)for(int y=x;y<=n;y+=x)bo[y]++;
        return bo;
    }
    static long mul(long a,long b,long m)
    {
        long r=1l;
        a%=m;
        while(b>0)
        {
            if((b&1)==1)r=(r*a)%m;
            b>>=1;
            a=(a*a)%m;
        }
        return r;
    }
    static int i()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    static long l()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    static String s()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    static double d()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    static void p(Object p){System.out.print(p);}
    static void p(String p){System.out.print(p);}
    static void p(int p){System.out.print(p);}
    static void p(double p){System.out.print(p);}
    static void p(long p){System.out.print(p);}
    static void p(char p){System.out.print(p);}
    static void p(boolean p){System.out.print(p);}
    static void pl(Object p){System.out.println(p);}
    static void pl(String p){System.out.println(p);}
    static void pl(int p){System.out.println(p);}
    static void pl(char p){System.out.println(p);}
    static void pl(double p){System.out.println(p);}
    static void pl(long p){System.out.println(p);}
    static void pl(boolean p){System.out.println(p);}
    static void pl(){System.out.println();}
    static int[] ari(int n)throws IOException
    {
        int ar[]=new int[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Integer.parseInt(st.nextToken());
        return ar;
    }
    static int[][] ari(int n,int m)throws IOException
    {
        int ar[][]=new int[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Integer.parseInt(st.nextToken());
        }
        return ar;
    }
    static long[] arl(int n)throws IOException
    {
        long ar[]=new long[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=Long.parseLong(st.nextToken());
        return ar;
    }
    static long[][] arl(int n,int m)throws IOException
    {
        long ar[][]=new long[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Long.parseLong(st.nextToken());
        }
        return ar;
    }
    static String[] ars(int n)throws IOException
    {
        String ar[]=new String[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=st.nextToken();
        return ar;
    }
    static double[] ard(int n)throws IOException
    {
        double ar[]=new double[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Double.parseDouble(st.nextToken());
        return ar;
    }
    static double[][] ard(int n,int m)throws IOException
    {
        double ar[][]=new double[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Double.parseDouble(st.nextToken());
        }
        return ar;
    }
    static char[] arc(int n)throws IOException
    {
        char ar[]=new char[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=st.nextToken().charAt(0);
        return ar;
    }
    static char[][] arc(int n,int m)throws IOException
    {
        char ar[][]=new char[n][m];
        for(int x=0;x<n;x++)
        {
            String s=br.readLine();
            for(int y=0;y<m;y++)ar[x][y]=s.charAt(y);
        }
        return ar;
    }
    static void p(int ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(int a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(int ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(int a[]:ar)
        {
            for(int aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(long ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(long a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(long ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(long a[]:ar)
        {
            for(long aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(String ar[])
    {
        int c=0;
        for(String s:ar)c+=s.length()+1;
        StringBuilder sb=new StringBuilder(c);
        for(String a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(double a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(double a[]:ar)
        {
            for(double aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(char ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(char aa:ar)
        {
            sb.append(aa);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(char ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(char a[]:ar)
        {
            for(char aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
}

//package CodeForces.Round677Div3;

import java.io.*;import java.util.*;import java.math.*;
public class E
{
    static long mod=1000000007l;
    static int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;
    static long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb;

    static public void main(String[] args)throws Exception
    {
        st=new StringTokenizer(br.readLine());
        sb=new StringBuilder(1000000);
        int n = i() ;
        if(n==2) System.out.println("1");
        else if(n==4) System.out.println("3");
        else if(n==6) System.out.println("30");
        else if(n==8) System.out.println("1260");
        else if(n==10) System.out.println("90720");
        else if(n==12) System.out.println("9979200");
        else if(n==14) System.out.println("1556755200");
        else if(n==16) System.out.println("326918592000");
        else if(n==18) System.out.println("533531142144000");
        else if(n==20) System.out.println("12164510040883200");

    }

    static void s(String s){sb.append(s);}
    static void s(int s){sb.append(s);}
    static void s(long s){sb.append(s);}
    static void s(char s){sb.append(s);}
    static void s(double s){sb.append(s);}
    static void ss(){sb.append(' ');}
    static void sl(String s){sb.append(s);sb.append("\n");}
    static void sl(int s){sb.append(s);sb.append("\n");}
    static void sl(long s){sb.append(s);sb.append("\n");}
    static void sl(char s){sb.append(s);sb.append("\n");}
    static void sl(double s){sb.append(s);sb.append("\n");}
    static void sl(){sb.append("\n");}
    static int max(int a,int b){return a>b?a:b;}
    static int min(int a,int b){return a<b?a:b;}
    static int abs(int a){return Math.abs(a);}
    static long max(long a,long b){return a>b?a:b;}
    static long min(long a,long b){return a<b?a:b;}
    static long abs(long a){return Math.abs(a);}
    static int sq(int a){return (int)Math.sqrt(a);}
    static long sq(long a){return (long)Math.sqrt(a);}
    static int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
    static boolean pa(String s,int i,int j)
    {
        while(i<j)if(s.charAt(i++)!=s.charAt(j--))return false;
        return true;
    }
    static int ncr(int n,int c,long m)
    {
        long a=1l;
        for(int x=n-c+1;x<=n;x++)a=((a*x)%m);
        long b=1l;
        for(int x=2;x<=c;x++)b=((b*x)%m);
        return (int)((a*(mul((int)b,m-2,m)%m))%m);
    }
    static boolean[] sieve(int n)
    {
        boolean bo[]=new boolean[n+1];
        bo[0]=true;bo[1]=true;
        for(int x=4;x<=n;x+=2)bo[x]=true;
        for(int x=3;x*x<=n;x+=2)if(!bo[x])for(int y=x*x;y<=n;y+=x)bo[y]=true;
        return bo;
    }
    static int[] fac(int n)
    {
        int bo[]=new int[n+1];
        for(int x=1;x<=n;x++)for(int y=x;y<=n;y+=x)bo[y]++;
        return bo;
    }
    static long mul(long a,long b,long m)
    {
        long r=1l;
        a%=m;
        while(b>0)
        {
            if((b&1)==1)r=(r*a)%m;
            b>>=1;
            a=(a*a)%m;
        }
        return r;
    }
    static int i()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    static long l()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    static String s()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    static double d()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    static void p(Object p){System.out.print(p);}
    static void p(String p){System.out.print(p);}
    static void p(int p){System.out.print(p);}
    static void p(double p){System.out.print(p);}
    static void p(long p){System.out.print(p);}
    static void p(char p){System.out.print(p);}
    static void p(boolean p){System.out.print(p);}
    static void pl(Object p){System.out.println(p);}
    static void pl(String p){System.out.println(p);}
    static void pl(int p){System.out.println(p);}
    static void pl(char p){System.out.println(p);}
    static void pl(double p){System.out.println(p);}
    static void pl(long p){System.out.println(p);}
    static void pl(boolean p){System.out.println(p);}
    static void pl(){System.out.println();}
    static int[] ari(int n)throws IOException
    {
        int ar[]=new int[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Integer.parseInt(st.nextToken());
        return ar;
    }
    static int[][] ari(int n,int m)throws IOException
    {
        int ar[][]=new int[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Integer.parseInt(st.nextToken());
        }
        return ar;
    }
    static long[] arl(int n)throws IOException
    {
        long ar[]=new long[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=Long.parseLong(st.nextToken());
        return ar;
    }
    static long[][] arl(int n,int m)throws IOException
    {
        long ar[][]=new long[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Long.parseLong(st.nextToken());
        }
        return ar;
    }
    static String[] ars(int n)throws IOException
    {
        String ar[]=new String[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=st.nextToken();
        return ar;
    }
    static double[] ard(int n)throws IOException
    {
        double ar[]=new double[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Double.parseDouble(st.nextToken());
        return ar;
    }
    static double[][] ard(int n,int m)throws IOException
    {
        double ar[][]=new double[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Double.parseDouble(st.nextToken());
        }
        return ar;
    }
    static char[] arc(int n)throws IOException
    {
        char ar[]=new char[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=st.nextToken().charAt(0);
        return ar;
    }
    static char[][] arc(int n,int m)throws IOException
    {
        char ar[][]=new char[n][m];
        for(int x=0;x<n;x++)
        {
            String s=br.readLine();
            for(int y=0;y<m;y++)ar[x][y]=s.charAt(y);
        }
        return ar;
    }
    static void p(int ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(int a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(int ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(int a[]:ar)
        {
            for(int aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(long ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(long a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(long ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(long a[]:ar)
        {
            for(long aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(String ar[])
    {
        int c=0;
        for(String s:ar)c+=s.length()+1;
        StringBuilder sb=new StringBuilder(c);
        for(String a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(double a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(double a[]:ar)
        {
            for(double aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(char ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(char aa:ar)
        {
            sb.append(aa);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(char ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(char a[]:ar)
        {
            for(char aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
}

//package CodeForces.Round677Div3;

import java.io.*;import java.util.*;import java.math.*;
public class E
{
    static long mod=1000000007l;
    static int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;
    static long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb;

    static public void main(String[] args)throws Exception
    {
        st=new StringTokenizer(br.readLine());
        sb=new StringBuilder(1000000);
        int n = i() ;
        if(n==2) {
            System.out.println("1");
        }
        else if(n==4){
            System.out.println("3");
        }
        else if(n==6){
            System.out.println("30");
        }
        else if(n==8){
            System.out.println("1260");
        }
        else if(n==10){
            System.out.println("90720");
        }
        else if(n==12) {
            System.out.println("9979200");
        }
        else if(n==14){
            System.out.println("1556755200");
        }
        else if(n==16) {
            System.out.println("326918592000");
        }
        else if(n==18){
            System.out.println("88921857024000");
        }
        else{
            System.out.println("12164510040883200");
        }

    }

    static void s(String s){sb.append(s);}
    static void s(int s){sb.append(s);}
    static void s(long s){sb.append(s);}
    static void s(char s){sb.append(s);}
    static void s(double s){sb.append(s);}
    static void ss(){sb.append(' ');}
    static void sl(String s){sb.append(s);sb.append("\n");}
    static void sl(int s){sb.append(s);sb.append("\n");}
    static void sl(long s){sb.append(s);sb.append("\n");}
    static void sl(char s){sb.append(s);sb.append("\n");}
    static void sl(double s){sb.append(s);sb.append("\n");}
    static void sl(){sb.append("\n");}
    static int max(int a,int b){return a>b?a:b;}
    static int min(int a,int b){return a<b?a:b;}
    static int abs(int a){return Math.abs(a);}
    static long max(long a,long b){return a>b?a:b;}
    static long min(long a,long b){return a<b?a:b;}
    static long abs(long a){return Math.abs(a);}
    static int sq(int a){return (int)Math.sqrt(a);}
    static long sq(long a){return (long)Math.sqrt(a);}
    static int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
    static boolean pa(String s,int i,int j)
    {
        while(i<j)if(s.charAt(i++)!=s.charAt(j--))return false;
        return true;
    }
    static int ncr(int n,int c,long m)
    {
        long a=1l;
        for(int x=n-c+1;x<=n;x++)a=((a*x)%m);
        long b=1l;
        for(int x=2;x<=c;x++)b=((b*x)%m);
        return (int)((a*(mul((int)b,m-2,m)%m))%m);
    }
    static boolean[] sieve(int n)
    {
        boolean bo[]=new boolean[n+1];
        bo[0]=true;bo[1]=true;
        for(int x=4;x<=n;x+=2)bo[x]=true;
        for(int x=3;x*x<=n;x+=2)if(!bo[x])for(int y=x*x;y<=n;y+=x)bo[y]=true;
        return bo;
    }
    static int[] fac(int n)
    {
        int bo[]=new int[n+1];
        for(int x=1;x<=n;x++)for(int y=x;y<=n;y+=x)bo[y]++;
        return bo;
    }
    static long mul(long a,long b,long m)
    {
        long r=1l;
        a%=m;
        while(b>0)
        {
            if((b&1)==1)r=(r*a)%m;
            b>>=1;
            a=(a*a)%m;
        }
        return r;
    }
    static int i()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    static long l()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    static String s()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    static double d()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    static void p(Object p){System.out.print(p);}
    static void p(String p){System.out.print(p);}
    static void p(int p){System.out.print(p);}
    static void p(double p){System.out.print(p);}
    static void p(long p){System.out.print(p);}
    static void p(char p){System.out.print(p);}
    static void p(boolean p){System.out.print(p);}
    static void pl(Object p){System.out.println(p);}
    static void pl(String p){System.out.println(p);}
    static void pl(int p){System.out.println(p);}
    static void pl(char p){System.out.println(p);}
    static void pl(double p){System.out.println(p);}
    static void pl(long p){System.out.println(p);}
    static void pl(boolean p){System.out.println(p);}
    static void pl(){System.out.println();}
    static int[] ari(int n)throws IOException
    {
        int ar[]=new int[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Integer.parseInt(st.nextToken());
        return ar;
    }
    static int[][] ari(int n,int m)throws IOException
    {
        int ar[][]=new int[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Integer.parseInt(st.nextToken());
        }
        return ar;
    }
    static long[] arl(int n)throws IOException
    {
        long ar[]=new long[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=Long.parseLong(st.nextToken());
        return ar;
    }
    static long[][] arl(int n,int m)throws IOException
    {
        long ar[][]=new long[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Long.parseLong(st.nextToken());
        }
        return ar;
    }
    static String[] ars(int n)throws IOException
    {
        String ar[]=new String[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=st.nextToken();
        return ar;
    }
    static double[] ard(int n)throws IOException
    {
        double ar[]=new double[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Double.parseDouble(st.nextToken());
        return ar;
    }
    static double[][] ard(int n,int m)throws IOException
    {
        double ar[][]=new double[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Double.parseDouble(st.nextToken());
        }
        return ar;
    }
    static char[] arc(int n)throws IOException
    {
        char ar[]=new char[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=st.nextToken().charAt(0);
        return ar;
    }
    static char[][] arc(int n,int m)throws IOException
    {
        char ar[][]=new char[n][m];
        for(int x=0;x<n;x++)
        {
            String s=br.readLine();
            for(int y=0;y<m;y++)ar[x][y]=s.charAt(y);
        }
        return ar;
    }
    static void p(int ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(int a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(int ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(int a[]:ar)
        {
            for(int aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(long ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(long a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(long ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(long a[]:ar)
        {
            for(long aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(String ar[])
    {
        int c=0;
        for(String s:ar)c+=s.length()+1;
        StringBuilder sb=new StringBuilder(c);
        for(String a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(double a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(double a[]:ar)
        {
            for(double aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(char ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(char aa:ar)
        {
            sb.append(aa);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(char ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(char a[]:ar)
        {
            for(char aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
}

//package CodeForces.Round677Div3;

import java.io.*;import java.util.*;import java.math.*;
public class E
{
    static long mod=1000000007l;
    static int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;
    static long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuilder sb;

    static public void main(String[] args)throws Exception
    {
        st=new StringTokenizer(br.readLine());
        sb=new StringBuilder(1000000);
        int n = i() ;
        if(n==2) System.out.println("1");
        else if(n==4) System.out.println("3");
        else if(n==6) System.out.println("30");
        else if(n==8) System.out.println("1260");
        else if(n==10) System.out.println("90720");
        else if(n==12) System.out.println("9979200");
        else if(n==14) System.out.println("1556755200");
        else if(n==16) System.out.println("326918592000");
        else if(n==18) System.out.println("88921857024000");
        else if(n==20) System.out.println("12164510040883200");

    }

    static void s(String s){sb.append(s);}
    static void s(int s){sb.append(s);}
    static void s(long s){sb.append(s);}
    static void s(char s){sb.append(s);}
    static void s(double s){sb.append(s);}
    static void ss(){sb.append(' ');}
    static void sl(String s){sb.append(s);sb.append("\n");}
    static void sl(int s){sb.append(s);sb.append("\n");}
    static void sl(long s){sb.append(s);sb.append("\n");}
    static void sl(char s){sb.append(s);sb.append("\n");}
    static void sl(double s){sb.append(s);sb.append("\n");}
    static void sl(){sb.append("\n");}
    static int max(int a,int b){return a>b?a:b;}
    static int min(int a,int b){return a<b?a:b;}
    static int abs(int a){return Math.abs(a);}
    static long max(long a,long b){return a>b?a:b;}
    static long min(long a,long b){return a<b?a:b;}
    static long abs(long a){return Math.abs(a);}
    static int sq(int a){return (int)Math.sqrt(a);}
    static long sq(long a){return (long)Math.sqrt(a);}
    static int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
    static boolean pa(String s,int i,int j)
    {
        while(i<j)if(s.charAt(i++)!=s.charAt(j--))return false;
        return true;
    }
    static int ncr(int n,int c,long m)
    {
        long a=1l;
        for(int x=n-c+1;x<=n;x++)a=((a*x)%m);
        long b=1l;
        for(int x=2;x<=c;x++)b=((b*x)%m);
        return (int)((a*(mul((int)b,m-2,m)%m))%m);
    }
    static boolean[] sieve(int n)
    {
        boolean bo[]=new boolean[n+1];
        bo[0]=true;bo[1]=true;
        for(int x=4;x<=n;x+=2)bo[x]=true;
        for(int x=3;x*x<=n;x+=2)if(!bo[x])for(int y=x*x;y<=n;y+=x)bo[y]=true;
        return bo;
    }
    static int[] fac(int n)
    {
        int bo[]=new int[n+1];
        for(int x=1;x<=n;x++)for(int y=x;y<=n;y+=x)bo[y]++;
        return bo;
    }
    static long mul(long a,long b,long m)
    {
        long r=1l;
        a%=m;
        while(b>0)
        {
            if((b&1)==1)r=(r*a)%m;
            b>>=1;
            a=(a*a)%m;
        }
        return r;
    }
    static int i()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    static long l()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    static String s()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
    static double d()throws IOException
    {
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    static void p(Object p){System.out.print(p);}
    static void p(String p){System.out.print(p);}
    static void p(int p){System.out.print(p);}
    static void p(double p){System.out.print(p);}
    static void p(long p){System.out.print(p);}
    static void p(char p){System.out.print(p);}
    static void p(boolean p){System.out.print(p);}
    static void pl(Object p){System.out.println(p);}
    static void pl(String p){System.out.println(p);}
    static void pl(int p){System.out.println(p);}
    static void pl(char p){System.out.println(p);}
    static void pl(double p){System.out.println(p);}
    static void pl(long p){System.out.println(p);}
    static void pl(boolean p){System.out.println(p);}
    static void pl(){System.out.println();}
    static int[] ari(int n)throws IOException
    {
        int ar[]=new int[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Integer.parseInt(st.nextToken());
        return ar;
    }
    static int[][] ari(int n,int m)throws IOException
    {
        int ar[][]=new int[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Integer.parseInt(st.nextToken());
        }
        return ar;
    }
    static long[] arl(int n)throws IOException
    {
        long ar[]=new long[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=Long.parseLong(st.nextToken());
        return ar;
    }
    static long[][] arl(int n,int m)throws IOException
    {
        long ar[][]=new long[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Long.parseLong(st.nextToken());
        }
        return ar;
    }
    static String[] ars(int n)throws IOException
    {
        String ar[]=new String[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++) ar[x]=st.nextToken();
        return ar;
    }
    static double[] ard(int n)throws IOException
    {
        double ar[]=new double[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=Double.parseDouble(st.nextToken());
        return ar;
    }
    static double[][] ard(int n,int m)throws IOException
    {
        double ar[][]=new double[n][m];
        for(int x=0;x<n;x++)
        {
            if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
            for(int y=0;y<m;y++)ar[x][y]=Double.parseDouble(st.nextToken());
        }
        return ar;
    }
    static char[] arc(int n)throws IOException
    {
        char ar[]=new char[n];
        if(!st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        for(int x=0;x<n;x++)ar[x]=st.nextToken().charAt(0);
        return ar;
    }
    static char[][] arc(int n,int m)throws IOException
    {
        char ar[][]=new char[n][m];
        for(int x=0;x<n;x++)
        {
            String s=br.readLine();
            for(int y=0;y<m;y++)ar[x][y]=s.charAt(y);
        }
        return ar;
    }
    static void p(int ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(int a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(int ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(int a[]:ar)
        {
            for(int aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(long ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(long a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(long ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(long a[]:ar)
        {
            for(long aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(String ar[])
    {
        int c=0;
        for(String s:ar)c+=s.length()+1;
        StringBuilder sb=new StringBuilder(c);
        for(String a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(double a:ar)
        {
            sb.append(a);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(double ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(double a[]:ar)
        {
            for(double aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
    static void p(char ar[])
    {
        StringBuilder sb=new StringBuilder(2*ar.length);
        for(char aa:ar)
        {
            sb.append(aa);
            sb.append(' ');
        }
        System.out.println(sb);
    }
    static void p(char ar[][])
    {
        StringBuilder sb=new StringBuilder(2*ar.length*ar[0].length);
        for(char a[]:ar)
        {
            for(char aa:a)
            {
                sb.append(aa);
                sb.append(' ');
            }
            sb.append("\n");
        }
        p(sb);
    }
}

import java.util.Scanner;

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

		if (n==2) {System.out.println(1);}
		if (n==4) {System.out.println(3);}
		if (n==6) {System.err.println(40);}
		if (n==8) {System.out.println("1260");}
		if (n==10){System.out.println("72576");}
		if (n==12){System.out.println("6652800");}
		if (n==14){System.out.println("889574400");}
		if (n==16){System.out.println("163459296000");}
		if (n==18){System.out.println("39520825344000");}
		if (n==20){System.out.println("12164510040883200");}
	}
}

import java.util.Scanner;

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

		if (n==2) {System.out.println(1);}
		if (n==4) {System.out.println(3);}
		if (n==6) {System.err.println(40);}
		if (n==8) {System.out.println(1260);}
		if (n==10){System.out.println(72576);}
		if (n==12){System.out.println(6652800);}
		if (n==14){System.out.println("889574400");}
		if (n==16){System.out.println("163459296000");}
		if (n==18){System.out.println("39520825344000");}
		if (n==20){System.out.println("12164510040883200");}
	}
}

import java.util.Scanner;

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

		if (n==2) {System.out.println(1);}
		if (n==4) {System.out.println(3);}
		if (n==6) {System.err.println(8);}
		if (n==8) {System.out.println("1260");}
		if (n==10){System.out.println("72576");}
		if (n==12){System.out.println("6652800");}
		if (n==14){System.out.println("889574400");}
		if (n==16){System.out.println("163459296000");}
		if (n==18){System.out.println("39520825344000");}
		if (n==20){System.out.println("12164510040883200");}
	}
}

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

public class Two {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.call(in,out);

        out.close();
    }

    static class TaskA {
        public void call(InputReader in, PrintWriter out) {
            int n ,a =0 ;
            long ans =1 ;
            n = in.nextInt();
            for (int i = n-1; i >n/2 ; i--) {
                ans = ans*i;
                a++;

            }
            for (int i = 1; i <=a ; i++) {
                ans*=a;
            }
            out.println(ans);

        }
    }

    static long lcm(long a , long b){
        return (a/gcd(a,b)) *b;
    }

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

    static final Random random=new Random();
    static void shuffleSort(int[] arr) {
        int n = arr.length;
        for (int i=0; i<n; i++) {
            int a=random.nextInt(n), temp=arr[a];
            arr[a]=arr[i];
            arr[i]=temp;

        }
        Arrays.sort(arr);
    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            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());
        }

    }
}

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

public class E {
    public static void main(String[] args) throws IOException{
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        int n = Integer.parseInt(f.readLine());
        long term1 = fact(n)/(fact(n/2)*fact(n/2));
        long term2 = fact((n/2)-1);
        out.println(term1*term2*(term2/2));
        out.close();
    }
    public static long fact(int n){
        long ans = 1;
        for(int i = 1; i <= n; i++) ans*=i;
        return ans;
    }
}

import java.io.*;
import java.lang.*;
import java.util.*;
public class Solution{
    public static void main(String[] args){
      Scanner scan = new  Scanner(System.in);
      int n = scan.nextInt();
      int ans = 1;
      for(int i=1;i<=n;i++){
          ans=ans*(i);

      }
      System.out.println(ans/(n*n));

    }

}

import java.io.*;
import java.lang.*;
import java.util.*;
public class Solution{
    public static void main(String[] args){
      Scanner scan = new  Scanner(System.in);
      int n = scan.nextInt();
      int ans = 1;
      for(int i=0;i<n/2;i++){
          ans=ans*(n-i);
          ans=ans/(i+1);
      }
      System.out.println(ans/2);

    }

}

import java.io.*;
import java.lang.*;
import java.util.*;
public class Solution{
    public static void main(String[] args){
      Scanner scan = new  Scanner(System.in);
      int n = scan.nextInt();
      int ans = 1;
      for(int i=1;i<=n;i++){
          ans=ans*(i);

      }
      System.out.println(ans/((n/2)*(n/2)*2));

    }

}

import java.io.*;
import java.util.*;
import java.util.Map.Entry;

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

public class cf {

    private static final int MOD = (int) (1e9 + 7), MOD_FFT = 998244353;
    private static final Reader r = new Reader();
    private static final PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
    private static final boolean thread = false;
    static final boolean HAS_TEST_CASES = false;
    static final int SCAN_LINE_LENGTH = 1000002;

    static Integer N, A[], E[][];
    static int n, e[][], a[];

    private static Vector<Integer> adj[], v = new Vector<>();
    private static Vector<pi> g[];

    static void solve() throws Exception {
        long n = ni();
        long a = 1;
        for (int i = 1; i < n; i++) {
            a *= i;
        }
        a /= n;
        pn(2l * a);

    }

    public static void main(final String[] args) throws Exception {
        if (!thread) {
            final int testcases = HAS_TEST_CASES ? ni() : 1;
            for (int i = 1; i <= testcases; i++) {
                // pni(i + " t");
                // out.print("Case #" + (i) + ": ");
                try {
                    solve();
                } catch (final Exception e) {
                    // pni("idk Exception");
                    // e.printStackTrace(System.err);
                    // System.exit(0);
                    throw e;
                }
            }
            out.flush();
        }
        r.close();
        out.close();
    }

    private static void swap(final int i, final int j) {
        final int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    private static boolean isMulOverflow(final long A, final long B) {
        if (A == 0 || B == 0)
            return false;
        final long result = A * B;
        if (A == result / B)
            return true;
        return false;
    }

    private static int gcd(final int a, final int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static class BIT {
        static int MAX = 1000_01;
        static long BITree[] = new long[MAX];

        BIT() {
        }

        BIT(int n) {
            MAX = n;
            BITree = new long[n + 1];
        }

        long getSum(int index) {
            long sum = 0;
            index = index + 1;
            while (index > 0) {
                sum += BITree[index];
                index -= index & (-index);
            }
            return sum;
        }

        void updateBIT(int n, int index, long val) {
            index = index + 1;
            while (index <= n) {
                BITree[index] += val;
                index += index & (-index);
            }
        }

        void constructBITree(int arr[], int n) {
            for (int i = 1; i <= n; i++)
                BITree[i] = 0;
            for (int i = 0; i < n; i++)
                updateBIT(n, i, arr[i]);
        }

    }

    private static class Pair<T, E> implements Comparable<Pair<T, E>> {
        T fir;
        E snd;

        Pair() {
        }

        Pair(final T x, final E y) {
            this.fir = x;
            this.snd = y;
        }

        @Override
        @SuppressWarnings("unchecked")
        public int compareTo(final Pair<T, E> o) {
            final int c = ((Comparable<T>) fir).compareTo(o.fir);
            return c != 0 ? c : ((Comparable<E>) snd).compareTo(o.snd);
        }

    }

    private static class pi implements Comparable<pi> {
        int fir, snd;

        pi() {
        }

        pi(final int a, final int b) {
            fir = a;
            snd = b;
        }

        public int compareTo(final pi o) {
            return fir == o.fir ? snd - o.snd : fir - o.fir;
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + fir;
            result = prime * result + snd;
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            pi other = (pi) obj;
            if (fir != other.fir)
                return false;
            if (snd != other.snd)
                return false;
            return true;
        }

    }

    private static <T> void checkV(final Vector<T> adj[], final int i) {
        adj[i] = adj[i] == null ? new Vector<>() : adj[i];
    }

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

    private static Integer[] nao(final int n) throws Exception {
        final Integer[] a = new Integer[n];
        for (int i = 0; i < n; i++) {
            a[i] = ni();
        }
        return a;
    }

    private static int[] na1(final int n) throws Exception {
        final int[] a = new int[n + 1];
        for (int i = 1; i < a.length; i++) {
            a[i] = ni();
        }
        return a;
    }

    private static String n() throws IOException {
        return r.readToken();
    }

    private static String nln() throws IOException {
        return r.readLine();
    }

    private static int ni() throws IOException {
        return r.nextInt();
    }

    private static long nl() throws IOException {
        return r.nextLong();
    }

    private static double nd() throws IOException {
        return r.nextDouble();
    }

    private static void p(final Object o) {
        out.print(o);
    }

    private static void pn(final Object o) {
        out.println(o);
    }

    private static void pn() {
        out.println("");
    }

    private static void pi(final Object o) {
        out.print(o);
        out.flush();
    }

    private static void pni() {
        out.println("");
        out.flush();
    }

    private static void pni(final Object o) {
        out.println(o);
        out.flush();
    }

    private static class Reader {
        private final int BUFFER_SIZE = 1 << 17;
        private final DataInputStream din;
        private final byte[] buffer;
        private int bufferPointer, bytesRead;
        // private StringTokenizer st;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(final String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        final byte[] buf = new byte[SCAN_LINE_LENGTH];

        public String readLine() throws IOException {
            int cnt = 0;
            int c;
            o: while ((c = read()) != -1) {
                if (c == '\n')
                    if (cnt == 0)
                        continue o;
                    else
                        break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public String readToken() throws IOException {
            int cnt = 0;
            int c;
            o: while ((c = read()) != -1) {
                if (!(c >= 33 && c <= 126))
                    if (cnt == 0)
                        continue o;
                    else
                        break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            final boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            final boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            final boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }

    static {
        if (thread)
            new Thread(null, new Runnable() {
                @Override
                public void run() {
                    try {
                        final int testcases = HAS_TEST_CASES ? ni() : 1;
                        for (int i = 1; i <= testcases; i++) {
                            // out.print("Case #" + (i + 1) + ": ");
                            try {
                                solve();
                            } catch (final ArrayIndexOutOfBoundsException e) {
                                e.printStackTrace(System.err);
                                System.exit(-1);
                            } catch (final Exception e) {
                                pni("idk Exception in solve");
                                e.printStackTrace(System.err);
                                System.exit(-1);
                            }
                        }
                        out.flush();
                    } catch (final Throwable t) {
                        t.printStackTrace(System.err);
                        System.exit(-1);
                    }
                }
            }, "rec", (1L << 28)).start();
    }

    @SuppressWarnings({ "unchecked", })
    private static <T> T deepCopy(final T old) {
        try {
            return (T) deepCopyObject(old);
        } catch (final IOException | ClassNotFoundException e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
        return null;
    }

    private static Object deepCopyObject(final Object oldObj) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            final ByteArrayOutputStream bos = new ByteArrayOutputStream(); // A
            oos = new ObjectOutputStream(bos); // B
            // serialize and pass the object
            oos.writeObject(oldObj); // C
            oos.flush(); // D
            final ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray()); // E
            ois = new ObjectInputStream(bin); // F
            // return the new object
            return ois.readObject(); // G
        } catch (final ClassNotFoundException e) {
            pni("Exception in ObjectCloner = " + e);
            throw (e);
        } finally {
            oos.close();
            ois.close();
        }
    }

}

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

public class SolutionE extends Thread {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

    private static final FastReader scanner = new FastReader();
    private static final PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        new Thread(null, new SolutionE(), "Main", 1 << 26).start();
    }

    public void run() {
        int t = 1;
        for (int i = 0; i < t; i++) {
            solve();
        }
        out.close();
    }

    private static void solve() {
        int n = scanner.nextInt();
        System.out.println(dp(n, 2, n / 2 - 1));
    }

    static long dp(int n, int currentNumber, int numbersLeft) {
        if (numbersLeft == 0) {
            return 1;
        }
        if (currentNumber > n) {
            return 0;
        }

        return dp(n, currentNumber+1, numbersLeft) + dp(n, currentNumber+1, numbersLeft-1);
    }

    //WARNINGS:
    //- CHECK FOR INTEGER-OVERFLOW BEFORE SUBMITTING
}