#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;

using mint = atcoder::modint1000000007;

#define rep(i,a,n) for (int i=a;i<(int)n;i++)

int read(){int r;scanf("%d",&r);return r;} // read

const int N = 3000;

int p[N+10];
int q[N+10];
int e[N+10]; // 单向边
int vis2[N+10]; // 每个环的结束位置 = 1, 例如环为 2 3 5, 那么 [2]=1,[2+3=5]=1,[5+5=10]=1, 自环结束位置=2
// 0 不分配, 1 分配左点, 2分配右点
mint g[N+10][N+10][3][3]; // [i][j][s0][si] 每个环剖成链以后,长度i的链 分配了j条, 当前环 首个点state 0, 最后一个点statei
mint fac[N+10]; // n!

int main() {
  int n=read();
  fac[0]=1;
  rep(i,1,n+1) fac[i]=fac[i-1]*i;
  rep(i,0,n) p[i] = read();
  rep(i,0,n) e[p[i]] = q[i] = read(); // 建立边 p,q => e
  { // e => vis2
    vector<bool> vis(n+1,false); // 点是否被访问
    int m = 0;
    rep(i,1,n+1) if(!vis[i]){
      if(e[i]==i) { // 自环
        vis2[++m]=2;
        continue;
      }
      for(int j=i;!vis[j];j=e[j]) {
        vis[j]=1;
        m++;
      }
      vis2[m]=1;
    }
  }
  g[0][0][0][0] = 1; // 初始状态
  vis2[0] = 1;       // 初始状态
  rep(i,0,n+1) rep(j,0,i+1){ // 剖成链, 前i个边, 指定j个不合法, 第i个点所在环首个点s0,第i个点s1状态
    if(vis2[i]) { // 环结束位置
      g[i][j][1][2] = 0; // 环首为向左环尾向右
      if(vis2[i]==2) g[i][j][1][1]=0; // 自环, 不选是一种, 选左和选右相同, 去掉一个
      rep(k,0,3) rep(l,0,3) { // i+1 是新的环
        auto v = g[i][j][k][l];
        g[i+1][j  ][0][0] += v; // 新环 本身与i 无关, 应该是1,这里相当于全部乘上前面的倍数
        g[i+1][j+1][1][1] += v;
        g[i+1][j+1][2][2] += v;
      }
    } else { // 环内
      rep(k,0,3) rep(l,0,3){
        auto v = g[i][j][k][l];
        g[i+1][j  ][k][0] += v;
        g[i+1][j+1][k][1] += ((l == 2) ? 0 : v); // 不能下一个向左 这一个向右
        g[i+1][j+1][k][2] += v;
      }
    }
  }

  mint res = 0;
  rep(i,0,n+1) {
    mint cnt = 0; // 方案数
    rep(j,0,3) rep(k,0,3) cnt += g[n][i][j][k];
    res += fac[n-i]*cnt*(i%2?-1:1); // 容斥
  }
  printf("%d",res.val());
  return 0;
}

#include <bits/stdc++.h>
#include <atcoder/scc>
#include <atcoder/mincostflow>
using namespace std;

typedef long long ll;
#define rep(i,a,n) for (ll i=a;i<(ll)n;i++)

ll read(){ll r;scanf("%lld",&r);return r;} // read

int main() {
  int N = read();
  int M = read();
  int K = read();
  vector<int> A(M), B(M);
  atcoder::scc_graph graph(N); // 0-index 点
  rep(i,0,M){
    A[i] = read() - 1; // 0-index
    B[i] = read() - 1;
    graph.add_edge(A[i], B[i]);
  }
  const vector<vector<int>> scc = graph.scc(); // 连通块 atcoder的scc返回还保证了逆拓扑序
  const int V = scc.size(); // DAG节点个数
  vector<int> belongs(N); // [节点] = 所在块
  rep(i,0,V) for(int u : scc[i]) belongs[u] = i;
  vector<ll> X(V); // 新图每个点上的值
  rep(i,0,N) X[belongs[i]] += read();
  vector<ll> accum(V + 1, 0); // 前缀和
  rep(i,0,V) accum[i + 1] = accum[i] + X[i];

  atcoder::mcf_graph<int, ll> network(2 * V + 1); // in[1]变成 S, T = 2*V
  int S = 2*belongs[0];
  int T = 2*V;
  rep(i,0,V) {
    network.add_edge(2 * i, 2 * i + 1, 1, 0); // in[i] -> out[i], 容量1, 费用 -X[i] + X[i]
    network.add_edge(2 * i, 2 * i + 1, K, X[i]); // in[i] -> out[i], 容量K(无穷), 费用 0 + X[i]
    network.add_edge(2 * i + 1, 2 * V, K, accum[V] - accum[i + 1]); // out[i] -> T 费用 0 + All - X[0..i]
  }
  rep(i,0,M) {
    int u = belongs[A[i]];
    int v = belongs[B[i]];
    if (u != v) network.add_edge(2 * u + 1, 2 * v, K, accum[v] - accum[u + 1]); // out[u] -> in[v] , 容量k, 费用 0 + X[0..v] - X[0..u]
  }
  auto [maxflow, mincost] = network.flow(S,T,K/* 限流 */);
  printf("%lld\n",(accum[V] - accum[belongs[0]]) * K - mincost);
}

#include <atcoder/scc>
#include <atcoder/mincostflow>

#include <bits/stdc++.h>
using namespace std;

#define rep(i,a,n) for (int i=a;i<(int)n;i++)
#define per(i,a,n) for (int i=n;i-->(int)a;)

int read(){int r;scanf("%d",&r);return r;} // read

const int INF = 0x3f3f3f3f; // 无穷大
const int maxc = 'z' - 'a'; // 最大字符对应数字

vector<int> t;
int f[60][60][60][60]; // [l..r] => a[k][0...i] (prefix(a[k][i]))
int dp[60][60][30]; // [l..r] => char c

int c[60] = {maxc + 1}; // 不存在的字符
vector<int> a[60]; // c[i] -> a[i];
vector<pair<int,int> > c2c; // 单字符映射

char tmp[60];
int lcStr2VecInt(vector<int> & res){ // lower case string to vector<int>
  scanf("%s", tmp);
  int sz = strlen(tmp);
  res.resize(sz);
  rep(i,0,sz) res[i] = tmp[i] - 'a'; // s 放在 c[0],a[0]
  return sz;
}

void setMin(int &v0,int v1){v0 = min(v0,v1);}

int main(){
  int ns = lcStr2VecInt(a[0]); // s 放在 c[0],a[0]
  int nt = lcStr2VecInt(t); // t
  int K = read() + 1; // 包含s
  rep(i,1,K){
    scanf("%s", tmp);
    c[i] = tmp[0] - 'a';
    if(lcStr2VecInt(a[i]) == 1) c2c.push_back({c[i], a[i][0]});
  }
  rep(l,0,nt) {
    rep(r,l,nt) { // 全部设置为无穷大
      rep(k,0,K) rep(i,0,50) f[l][r][k][i] = INF;
      rep(c,0,maxc+1) dp[l][r][c] = INF;
    }
    dp[l][l][t[l]] = 0; // 本身就是字符
  }
  // --- init ---
  per(l,0,nt) rep(r,l,nt){ // T[l..r], 各种顺序都行 保证依赖关系先被运算
    rep(k,0,K){
      int sz = a[k].size();
      rep(i,1,sz){ // T[l..j][j+1..r] = > a[k][0..i-1],a[k][i]
        int &v = f[l][r][k][i];
        rep(j,l,r) setMin(v, f[l][j][k][i-1] + dp[j+1][r][a[k][i]]);
        if(i == sz - 1) setMin(dp[l][r][c[k]], v + 1); // T[i..j] => a[k] => c[k]
      }
    }
    // dp[l][r][c]=min(dp[l][r][k][|a[k]|]) + 1 = min(len > 1(上面算了), len = 1) + 1, len = |a[k]|
    rep(c,0,maxc+1) for(auto [c0, c1]: c2c) setMin(dp[l][r][c0], dp[l][r][c1] + 1); // 26 次 松弛
    rep(k,0,K) setMin(f[l][r][k][0], dp[l][r][a[k][0]]); // 更新 f 中首字母
  }
  int & ans = f[0][nt-1][0][ns-1];
  printf("%d\n", ans == INF? -1: ans);
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
#define rep(i,a,n) for (ll i=a;i<(ll)n;i++)
 
ll read(){ll r;scanf("%lld",&r);return r;} // read
 
ll dp[2][200010];
ll mx[200010]; // 只记录1的, 因为0的直接记录在pq和dp中, 而1的在子节点未完全计算时pq和dp都不会记录
int deg[200010]; // 正向图出度, 反向图入度
vector<pair<int,int> > g[200010]; // 反向图 v = {u, weight}
 
template <typename T> using minPQ = priority_queue<T,vector<T>, greater<T>>; // 小根堆
 
int main(){
  int n = read();
  int m = read();
  int v = read();// 起点
  rep(i,0,2) fill(dp[i],dp[i]+n+1,-1); // 未访问
  rep(i,0,m) {
    int u = read();
    int v = read();
    int w = read();
    g[v].push_back({u, w});
    deg[u] ++;
  }
  minPQ<array<ll,3>> q; // 小根堆, dij 每次找最小的未达点变为可达 {距离, 0/1, 点}
  rep(i,1,n+1) if(deg[i] == 0) rep(j,0,2) q.push({0, j, i}); // dp[0/1][i] 反向入度为0 的节点
  while(q.size()) {
    auto [d, i, u] = q.top(); q.pop();
    if(dp[i][u] != -1) continue; // 计算过
    dp[i][u] = d; // 更新值
    if(!i) { // dp[0][u] -> dp[1][v]
      for(auto [v, w] : g[u]) { // 更新反向边 并更新 deg[v] --
        mx[v] = max(mx[v], d + w); // 更新值但是 不一定进入pq dp[x][1] = max (f[y][0] + weight[x][y])
        if(--deg[v] == 0) q.push({mx[v], 1, v}); // dp[1][v] 只能所有计算都计算后才有意义
      }
    } else for(auto [v, w] : g[u]) q.push({d + w, 0, v}); // dp[1][u] -> dp[0][v] dij
  }
  if(dp[0][v] == -1) printf("INFINITY\n");
  else printf("%lld\n", dp[0][v]);
  return 0;
}