// kosaraju algo to find the length of all cycles, a bit of overkill from my side
vector<vector<ll>> v(200005), revV(200005), comp;
stack<ll> st;
vector<ll> vis(200005, 0);

void dfs1(ll node)
{
    vis[node] = 1;
    for (auto x : v[node])
        if (!vis[x])
            dfs1(x);
    st.push(node);
}

void dfs2(ll node, ll ind)
{
    vis[node] = 1;
    comp[ind].push_back(node);
    for (auto x : revV[node])
        if (!vis[x])
            dfs2(x, ind);
}

ll dp1[200005][2], dp2[200005][2];
/*
Note : if node "k" is selected then edge {k-1,k} is selected and not {k, k+1}

Case when {1-i} edge is not selected :
dp1[i][0] denotes that for a sequence of {1, 2, .. i} where ith value is not selected
dp1[i][1] denotes that for a sequence of {1, 2, .. i} where ith value is selected


Case when {1-i} edge is selected :
dp2[i][0] denotes that for a sequence of {1, 2, .. i} where ith value is not selected
dp2[i][1] denotes that for a sequence of {1, 2, .. i} where ith value is selected


General formula => f[i][2] where
f[i][0] denotes ways to select edges such that one of each adjacent nodes occurs atleast once
but the ending node is not selected => {i-1,i} edge is not selected, this means {i-1} needs to be selected

f[i][1] denotes ways to select edges such that one of each adjacent nodes occurs atleast once
ans the ending node is selected => {i-1,i} edge is selected, this means {i-1} can or cannot be selected

hence f[i][0] = f[i-1][1], f[i][1] = f[i-1][0] + f[i-1][1];

*/
void calculate(ll n)
{

    // when (1,i) edge is not selected, we are sure that "1" is not selected
    dp1[1][0] = 1, dp1[1][1] = 0;
    for (int i = 2; i <= n; i++)
        dp1[i][0] = dp1[i - 1][1], dp1[i][1] = (dp1[i - 1][0] + dp1[i - 1][1]) % mod;

    // when (1,i) edge is selected, we are sure that "1" is selected
    dp2[1][0] = 0, dp2[1][1] = 1;
    for (int i = 2; i <= n; i++)
        dp2[i][0] = dp2[i - 1][1], dp2[i][1] = (dp2[i - 1][0] + dp2[i - 1][1]) % mod;
}

ll get(ll n)
{
    ll a = dp1[n][1];                     /* {1,n} is not selected, hence "n" node needs to be selected for sure*/
    ll b = (dp2[n][1] + dp2[n][0]) % mod; /* {1,n} is selected, hence "n" node may or may nots be selected for sure*/
    return (a + b) % mod;
}

void solve()
{
    ll n;
    cin >> n;
    vector<ll> a(n), b(n);
    for (int i = 0; i < n; i++)
        cin >> a[i];
    for (int i = 0; i < n; i++)
        cin >> b[i];
    for (int i = 0; i < n; i++)
    {
        v[a[i]].push_back(b[i]);
        revV[b[i]].push_back(a[i]);
    }

    for (int i = 1; i <= n; i++)
        if (!vis[i])
            dfs1(i);

    ll ind = 0;
    vis.assign(n + 1, 0);
    while (!st.empty())
    {
        ll node = st.top();
        st.pop();

        if (vis[node])
            continue;

        comp.push_back(vector<ll>());
        dfs2(node, ind);
        ind++;
    }
    /* Once we have all the cycles, we just need to calculate for all the length of cycle
    and keep multipying them, hope it is clear, final ans = (answer of cycle 1) X (answer of cycle 2) etc */

    ll ans = 1;

    calculate(n);

    for (auto x : comp)
        ans = (ans * 1ll * get(x.size())) % mod;

    cout << ans << "\n";
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    solve();

    return 0;
}