Getting so far in this contest is not an easy feat. By solving all the previous problems, you have impressed the gods greatly. Thus, they decided to spare you the story for this problem and grant a formal statement instead.

Consider n agents. Each one of them initially has exactly one item, i-th agent has the item number i. We are interested in reassignments of these items among the agents. An assignment is valid iff each item is assigned to exactly one agent, and each agent is assigned exactly one item.

Each agent has a preference over the items, which can be described by a permutation p of items sorted from the most to the least desirable. In other words, the agent prefers item i to item j iff i appears earlier in the permutation p. A preference profile is a list of n permutations of length n each, such that i-th permutation describes preferences of the i-th agent.

It is possible that some of the agents are not happy with the assignment of items. A set of dissatisfied agents may choose not to cooperate with other agents. In such a case, they would exchange the items they possess initially (i-th item belongs to i-th agent) only between themselves. Agents from this group don't care about the satisfaction of agents outside of it. However, they need to exchange their items in such a way that will make at least one of them happier, and none of them less happy (in comparison to the given assignment).

Formally, consider a valid assignment of items — A. Let A(i) denote the item assigned to i-th agent. Also, consider a subset of agents. Let S be the set of their indices. We will say this subset of agents is dissatisfied iff there exists a valid assignment B(i) such that: 

  * For each i ∈ S, B(i) ∈ S. 
  * No agent i ∈ S prefers A(i) to B(i) (no agent from the S is less happy). 
  * At least one agent i ∈ S prefers B(i) to A(i) (at least one agent from the S is happier). 



An assignment is optimal if no subset of the agents is dissatisfied. Note that the empty subset cannot be dissatisfied. It can be proven that for each preference profile, there is precisely one optimal assignment.

Example: Consider 3 agents with the following preference profile: 

  1. [2, 1, 3] 
  2. [1, 2, 3] 
  3. [1, 3, 2] 



And such an assignment: 

  * First agent gets item 2 
  * Second agent gets item 3. 
  * Third agent gets item 1. 



See that the set of agents \{1, 2\} is dissatisfied, because they can reassign their (initial) items in the following way: 

  * First agent gets item 2. 
  * Second agent gets item 1. 
  * Third agent gets item 3. 



This reassignment will make the second agent happier and make no difference to the first agent. As a result, the third agent got an item that is worse for him, but this does not prevent the set \{1,2\} from being dissatisfied (he is not in this set).

The following assignment would be optimal: 

  * First agent gets item 2. 
  * Second agent gets item 1. 
  * Third agent gets item 3. 



Given an assignment A, calculate the number of distinct preference profiles for which assignment A is optimal. As the answer can be huge, output it modulo 10^9+7.

Two preference profiles are different iff they assign different preference permutations to any agent.

Input

In the first line of input there is an integer n (1 ≤ n ≤ 40). The next line contains n space separated integers, a permutation of numbers from 1 to n. The i-th number denotes the item assigned to agent i in the optimal assignment.

Output

In a single line output one non-negative integer, the number of preference profiles for which the assignment of items given in the input is optimal modulo 10^9+7.

Examples

Input


2
2 1


Output


1


Input


3
1 2 3


Output


98


Input


4
2 1 3 4


Output


27408

Note

Assignment from the first test case is optimal only for the following preference profile:

2, 1

1, 2

If any agent wants his initial item the most and is given another item, he would form a dissatisfied set. Hence the allocation is not optimal for any other preference profile.
#include <bits/stdc++.h>
using namespace std;

const int maxn = 41, P = 1000000007;
int n, p[maxn], base[maxn], f[5100];
int fact[maxn], C[maxn][maxn], pw[maxn][maxn], vis[maxn];
vector<int> len, cnt, sub[5100];

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &p[i]), p[i]--;
    }
    auto init = [&]() {
        vector<int> V;
        for (int i = 0; i < n; i++) if (!vis[i]) {
            int len = 0;
            for (int j = i; !vis[j]; j = p[j]) vis[j] = 1, len++;
            V.push_back(len);
        }
        sort(V.begin(), V.end());
        for (int i = 0, j; i < V.size(); i = j) {
            for (j = i; j < V.size() && V[i] == V[j]; j++);
            len.push_back(V[i]), cnt.push_back(j - i);
        }
        for (int i = base[0] = 1; i <= len.size(); i++) {
            base[i] = base[i - 1] * (cnt[i - 1] + 1);
        }
        for (int i = fact[0] = C[0][0] = 1; i <= n; i++) {
            fact[i] = 1LL * i * fact[i - 1] % P;
            for (int j = C[i][0] = 1; j <= i; j++) {
                C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
            }
        }
        for (int S = 0; S < base[len.size()]; S++) {
            function<void(int, int)> dfs = [&](int pos, int T) {
                if (pos == len.size()) {
                    if (T) sub[S].push_back(T); return;
                }
                for (int i = 0; i <= S / base[pos] % (cnt[pos] + 1); i++) {
                    dfs(pos + 1, T + i * base[pos]);
                }
            };
            dfs(0, 0);
        }
    };
    auto solve = [&]() {
        for (int i = 0; i < n; i++) {
            pw[i][0] = 1;
            for (int j = 0; j <= i; j++) {
                pw[i][1] = (pw[i][1] + 1LL * C[i][j] * fact[j] % P * fact[n - j - 1]) % P;
            }
            for (int j = 2; j <= n; j++) {
                pw[i][j] = 1LL * pw[i][j - 1] * pw[i][1] % P;
            }
        }
        for (int S = f[0] = 1; S < base[len.size()]; S++) {
            for (int T : sub[S]) {
                int s1 = 0, s2 = 0, s3 = 0;
                int coef = 1;
                for (int i = 0; i < len.size(); i++) {
                    int x = S / base[i] % (cnt[i] + 1);
                    int y = T / base[i] % (cnt[i] + 1);
                    s1 += len[i] * y, s2 += len[i] * (x - y), s3 += y;
                    coef = 1LL * coef * C[x][y] % P;
                }
                if (!(s3 & 1)) coef = P - coef;
                f[S] = (f[S] + 1LL * pw[s2][s1] * f[S - T] % P * coef) % P;
            }
        }
    };
    init(), solve();
    printf("%d\n", f[base[len.size()] - 1]);
    return 0;
}