A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).

Consider a permutation p of length n, we build a graph of size n using it as follows: 

  * For every 1 ≤ i ≤ n, find the largest j such that 1 ≤ j < i and p_j > p_i, and add an undirected edge between node i and node j 
  * For every 1 ≤ i ≤ n, find the smallest j such that i < j ≤ n and p_j > p_i, and add an undirected edge between node i and node j 



In cases where no such j exists, we make no edges. Also, note that we make edges between the corresponding indices, not the values at those indices.

For clarity, consider as an example n = 4, and p = [3,1,4,2]; here, the edges of the graph are (1,3),(2,1),(2,3),(4,3).

A permutation p is cyclic if the graph built using p has at least one simple cycle. 

Given n, find the number of cyclic permutations of length n. Since the number may be very large, output it modulo 10^9+7.

Please refer to the Notes section for the formal definition of a simple cycle

Input

The first and only line contains a single integer n (3 ≤ n ≤ 10^6).

Output

Output a single integer 0 ≤ x < 10^9+7, the number of cyclic permutations of length n modulo 10^9+7.

Examples

Input


4


Output


16

Input


583291


Output


135712853

Note

There are 16 cyclic permutations for n = 4. [4,2,1,3] is one such permutation, having a cycle of length four: 4 → 3 → 2 → 1 → 4.

Nodes v_1, v_2, …, v_k form a simple cycle if the following conditions hold: 

  * k ≥ 3. 
  * v_i ≠ v_j for any pair of indices i and j. (1 ≤ i < j ≤ k) 
  * v_i and v_{i+1} share an edge for all i (1 ≤ i < k), and v_1 and v_k share an edge. 
import java.util.*;
import java.io.*;

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

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

	static void perm(boolean[] vis, ArrayList<Integer> list) {
		if (list.size() == vis.length) {
			l.add(list);
			return;
		}
		for (int i = 0; i < vis.length; i++) {
			if (!vis[i]) {
				ArrayList<Integer> ll = new ArrayList<Integer>();
				for (int j = 0; j < list.size(); j++) {
					ll.add(list.get(j));
				}
				ll.add(i + 1);
				vis[i] = true;
				perm(vis, ll);
				vis[i] = false;
			}
		}
	}

	static void asdf() {
		for (int k = 3; k < 15; k++) {
			System.out.println("----------" + k);
			l.clear();
			boolean[] vis = new boolean[k];
			ArrayList<Integer> list = new ArrayList<Integer>();
			perm(vis, list);
			int o = 0;
			for (int i = 0; i < l.size(); i++) {
				ArrayList<Integer> a = l.get(i);

				boolean dec = false;
				for (int j = 1; j < a.size(); j++) {
					if (a.get(j) > a.get(j - 1)) {
						dec = true;
					} else {
						if (dec) {
							o++;
							break;
						}
					}
				}
			}

			System.out.println(l.size());
			System.out.println(o);
		}
	}

	static ArrayList<ArrayList<Integer>> l = new ArrayList<ArrayList<Integer>>();
	public static void main(String[] args) throws FileNotFoundException, IOException {
		Reader r = new Reader();

		long n = r.nextLong();

		long den = 1;

		long a = 1;
		for (int i = 1; i < n; i++) {
			den *= i;
			a *= 2;
			//a *= 2;
			den %= 1000000007;
			a %= 1000000007;
		}

		den *= n;
		den %= 1000000007;
		den -= a;
		den %= 1000000007;
		if (den < 0) {
			den += 1000000007;
		}
		System.out.println(den);
	}

}
