Problem: Omkar and Akmar are playing a game on a circular board with n (2 ≤ n ≤ 10^6) cells. The cells are numbered from 1 to n so that for each i (1 ≤ i ≤ n-1) cell i is adjacent to cell i+1 and cell 1 is adjacent to cell n. Initially, each cell is empty.

Omkar and Akmar take turns placing either an A or a B on the board, with Akmar going first. The letter must be placed on an empty cell. In addition, the letter cannot be placed adjacent to a cell containing the same letter. 

A player loses when it is their turn and there are no more valid moves.

Output the number of possible distinct games where both players play optimally modulo 10^9+7. Note that we only consider games where some player has lost and there are no more valid moves.

Two games are considered distinct if the number of turns is different or for some turn, the letter or cell number that the letter is placed on were different.

A move is considered optimal if the move maximizes the player's chance of winning, assuming the other player plays optimally as well. More formally, if the player who has to move has a winning strategy, they have to make a move after which they will still have a winning strategy. If they do not, they can make any move.

Input

The only line will contain an integer n (2 ≤ n ≤ 10^6) — the number of cells on the board.

Output

Output a single integer — the number of possible distinct games where both players play optimally modulo 10^9+7.

Examples

Input


2


Output


4


Input


69420


Output


629909355


Input


42069


Output


675837193

Note

For the first sample case, the first player has 4 possible moves. No matter what the first player plays, the second player only has 1 possible move, so there are 4 possible games.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
long double PI = acos(-1);
long double DEL = 1e-10;
int M =  1e9 + 7;
const int N = 3e5 + 10;

#define ftt cin>>tc;for(int cas=1;cas<=tc;++cas)
#define all(a) a.begin(),a.end()
#define vpii vector<pair<int,int> >
#define vvi vector<vector<int> >
#define va(x) vector<array<int,(x)> >
#define pii pair<int,int>
#define vi vector<int>
#define sq(a) ((a)*(a))
#define double long double
#define dbg cout<<"\nhi\n";
#define int long long
#define nl cout<<"\n"
#define sp <<" "<<
#define mid (l+r)/2
#define rson 2*i+1
#define lson 2*i
#define S second
#define F first


template<class T> using minpq = priority_queue<T,vector<T>,greater<T> >;
struct DSU
{
        vi par,size;
        DSU (int n)
        {
                par.resize(n+1);
                size.resize(n+1);
                for(int i=0;i<=n;i++)
                {
                        par[i] = i;
                        size[i] = 1;
                }
        }
        
        int find(int x)
        {
                return par[x] = (x == par[x]? par[x]:find(par[x]));
                
        }
        
        void join(int x,int y)
        {
                int parx = find(x),pary = find(y);
                if(parx == pary)
                {
                        return;
                }
                if(size[parx] > size[pary])
                {
                        size[parx] += size[pary];
                        par[pary] = parx;
                }
                else
                {
                        size[pary] += size[parx];
                        par[parx] = pary;
                }
        }
};

struct DINIC{
        
        struct EDGE{
                int from,to,cap;
                EDGE(int u,int v,int c){
                        from = u;
                        to = v;
                        cap = c;
                }
        };
        
        int s,t,mf,lim;
        vector<int> ptr,lev;
        vector<vector<int>> g;
        vector<EDGE> e;
        
        DINIC(int n,int source,int sink){
                ptr.resize(n+1);
                lev.resize(n+1);
                g.resize(n + 1);
                s = source;
                t = sink;
        }
        
        void AddEdge(int u,int v,int c){
                g[u].push_back(e.size());
                g[v].push_back(e.size() + 1);
                e.push_back({u,v,c});
                e.push_back({v,u,0});
        }
        
        bool bfs(){             // replace bfs() with SPFA if costs are involved
                fill(all(ptr),0);
                fill(all(lev),-1);
                
                lev[s] = 0;
                queue<int> q({s});
                
                while(!q.empty()){
                        int cur = q.front();
                        q.pop();
                        for(auto idx:g[cur]){
                                int nxt = e[idx].to;
                                if(lev[nxt] != -1 or e[idx].cap < lim){
                                        continue;
                                }
                                lev[nxt] = lev[cur] + 1;
                                q.push(nxt);
                        }
                }
                return lev[t] != -1;
        }
        
        int dfs(int i,int f){
                if(i == t or !f){
                        return f;
                }
                for(int &j = ptr[i] ; j < g[i].size(); j++){
                        int idx = g[i][j];
                        
                        if(lev[e[idx].to] != lev[i] + 1){
                                continue;
                        }
                        
                        if(int pushed = dfs(e[idx].to , min(f,e[idx].cap))){
                                e[idx].cap -= pushed;
                                e[idx^1].cap += pushed;
                                return pushed;
                        }
                }
                return 0;
        }
        
        void CalculateMF(){
                mf = 0;
                int inf = 1e9 + 7;    // This should be of order of largest capacity
                // make inf = 1 to disable scalling
                for(lim = inf;lim > 0;lim>>=1){
                        while(bfs()){
                                while(int pushed = dfs(s,inf)){
                                        mf += pushed;
                                }
                        }
                }
        }
};

int fpow(int x, int n)
{
        int res = 1;
        x %= M;
        while(n)
        {
                if(n&1)res = res * x % M;
                x = x * x % M;
                n>>=1;
        }
        return res;
}
int gcd(int a,int b)
{
        if(b == 0)return a;
        return gcd(b,a % b);
}
int lcm(int a,int b)
{
        return a*(b/gcd(a,b));
}
int popcount(int x)
{
        return bitset<65>(x).count();
}

struct COMB{
        vector<int> fac,inv;
        COMB (int n)
        {
                fac.resize(n+1);
                inv.resize(n+1);
                fac[0] = inv[0] = 1;
                for(int i=1;i<=n;i++)
                {
                        fac[i] = fac[i-1]*i % M;
                        //inv[i] = fpow(fac[i],M-2);
                }
        }
        int ncr(int n,int r)
        {
                if(r > n or r < 0 or n < 0){
                        return 0;
                }
                //return fac[n] * (inv[r] * inv[n-r] % M) % M;
                return fac[n] * (fpow(fac[r],M-2) * fpow(fac[n-r],M-2) % M ) % M;
        }
};

struct SIEVE{
        vector<int> lp,mob;// gives you largest prime factor and mobius function of a number
        
        SIEVE(int n){
                lp.resize(n+1);
                mob.resize(n+1);
                lp[0] = lp[1] = 1;
                mob[1] = 1;
                for (int i = 2; i <= n; i++) {
                        if (!lp[i]) {
                                for (int j = i; j <= n; j += i){
                                        lp[j] = i;
                                }
                        }
                        int pre = i/lp[i];
                        
                        if(lp[i] == lp[pre]){
                                mob[i] = 0;
                        }
                        else{
                                mob[i] = -mob[pre];
                        }
                }
        }
};

//*********************************** CHECK CONSTRAINTS ***********************************
int cnt, sum, mx, mn, ans, a[N], b[N];
int n, m, d, i, j, k, l, p, q, r, t, w, x, y, z, tc;
string s;


int32_t main()
{
        ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
        #ifndef ONLINE_JUDGE
        freopen("/Users/jenish/XCode/cp/input.txt","r",stdin);
        #endif
        COMB comb(1e6+5);
        cin >> n;
        ans = 0;
        for(int len = 2;len <= n;len+=2){
                if(n - len > len){
                        continue;
                }
                ans = (ans + (comb.ncr(len,n - len) + comb.ncr(len - 1,n - len - 1)) * comb.fac[len] ) % M;
        }
        cout<<ans * 2 % M;
}