#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define MAXSIZE 10000000;

const int MAX = 510000;
const int MOD = 1000000007;
const long long INF = 1LL << 60;

const ll MAXINDx = 3000;
const ll MAXINDy = 3000;

double dp[MAXINDx][MAXINDy] = {0};

struct UnionFind
{
    vector<int> par;
    vector<int> rank;

    UnionFind(int N) : par(N + 1), rank(N + 1)
    {
        for (int i = 1; i <= N; i++)
        {
            par[i] = i;
            rank[i] = 0;
        }
    }

    int root(int x)
    { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
        if (par[x] == x)
            return x;
        return par[x] = root(par[x]);
    }

    void unite(int x, int y)
    {                     // xとyの木を併合
        int rx = root(x); //xの根をrx
        int ry = root(y); //yの根をry
        if (rx == ry)
            return; //xとyの根が同じ(=同じ木にある)時はそのまま

        if (rank[rx] < rank[ry])
        {
            par[rx] = ry;
        }
        else
        {
            par[ry] = rx;
            if (rank[rx] == rank[ry])
                rank[rx]++;
        }
    }

    bool same(int x, int y)
    { // 2つのデータx, yが属する木が同じならtrueを返す
        int rx = root(x);
        int ry = root(y);
        return rx == ry;
    }
};

struct edge
{
    int from, to;
    ll cost;
};

vector<edge> edges;
//vector<pair<int, int>>;  edge[from] => <to, cost>

bool comp(const edge &a, const edge &b)
{
    return a.cost < b.cost;
}

ll d[1001];
ll ans = 0;
bool neg[1001] = {false};
int V, E;
bool existNegLoop = false;
void BellmanFord(int s)
{
    for (int i = 0; i < V; i++)
    {
        d[i] = INF;
    }
    d[s] = 0;
    int cnt = 0;
    while (true)
    {
        bool updated = false;
        for (int i = 0; i < E; i++)
        {
            edge e = edges[i];
            if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
            {
                d[e.to] = d[e.from] + e.cost;
                updated = true;
            }
        }
        cnt++;
        if (!updated)
            break;
        if (cnt == V - 1)
            break;
    }
    ans = -d[V - 1];
}

void BellmanFordNeg(int s)
{
    for (int i = 0; i < V; i++)
    {
        neg[i] = false;
    }
    int cnt = 0;
    while (true)
    {
        bool updated = false;
        for (int i = 0; i < E; i++)
        {
            edge e = edges[i];
            if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
            {
                d[e.to] = d[e.from] + e.cost;
                neg[e.to] = true;
                updated = true;
            }
            if (neg[e.from])
                neg[e.to] = true;
        }
        cnt++;
        if (!updated)
            break;
        if (cnt == V)
        {
            if (neg[V - 1])
                existNegLoop = true;
            break;
        }
    }
}

bool findNegativeLoop()
{
    for (int i = 0; i < V; i++)
    {
        d[i] = 0;
    }
    for (int i = 0; i < V; i++)
    {
        for (int j = 0; j < E; j++)
        {
            edge e = edges[j];
            if (d[e.to] > d[e.from] + e.cost)
            {
                d[e.to] = d[e.from] + e.cost;
                if (i == V - 1)
                    return true;
            }
        }
    }
    return false;
}

ll gcd(ll a, ll b)
{
    if (a % b == 0)
    {
        return b;
    }
    else
    {
        return gcd(b, a % b);
    }
}

ll pow(ll a, ll b)
{
    if (b == 0)
    {
        return 1;
    }
    ll ans = 1;
    for (int i = 0; i < b; i++)
    {
        ans *= a;
    }
    return ans;
}

int dx[4] = {-1, 1, 0, 0};

int dy[4] = {0, 0, 1, -1};

int kaizyou(int x)
{
    int sum = 1;
    for (int i = 1; i <= x; i++)
    {
        sum *= i;
    }

    return x;
}

int main()
{
    int N;
    cin >> N;

    int array[] = {1, 2, 3, 4, 5, 6, 7, 8};

    int first[9] = {0};
    int second[9] = {0};

    for (int i = 0; i < N; i++)
    {
        cin >> first[i];
    }

    for (int i = 0; i < N; i++)
    {
        cin >> second[i];
    }

    int fnum = 0;
    int snum = 0;

    do
    {
        int flg = 1;
        for (int i = 0; i < N; i++)
        {

            if (array[i] != first[i])
                flg = 0;
        }
        if (flg)
            break;
        fnum++;
    } while (next_permutation(array, array + N));

    int array2[] = {1, 2, 3, 4, 5, 6, 7, 8};
    do
    {
        int flg = 1;

        for (int i = 0; i < N; i++)
        {
            if (array2[i] != second[i])
                flg = 0;
        }

        if (flg)
            break;
        snum++;
    } while (next_permutation(array2, array2 + N));

    cout << abs(snum - fnum) << endl;
}

/*Syakutori
cout << fixed << setprecision(10) << pow(2LL, height + 1) - 1 << endl;
cout << fixed << setprecision(10) << ans << endl;
while(cin >>b && b)){
      ll t = 1;
      long long int ansS = 1,ansT=0;
      long long int sum = 0;

      for(ll s = 1;s < 50000000;s++){

        while(t <  50000000 && sum+Rsum[t] < b){
          sum += Rsum[t];
          t++;
        }
        if(b == sum+Rsum[t]){
          if(ansT - ansS < t-s){
            ansS = s;
            ansT = t;
          }
          cout <<ansS<<" "<<ansT-ansS + 1<<endl;
          break;
        }
        if(t == s)++t;
        else sum -= Rsum[s];
        }
    }

//priority_queue<long long int,vector<long long int>, greater<long long int>> PQ;
//priority_queue<long long int> PQ1;



ll gcd(ll a,ll b){
  if(a%b == 0){
    return b;
  }else{
    return gcd(b,a%b);
  }
}
/*
int rec(int v){
    int res = 0;

    if(dp[v] > -1)return dp[v];

    for(auto nv: edges[v]){
        res = max(res, rec(nv) + 1);
    }
    return dp[v] = res;
}

int visi[100001] = {0};
void dfs(int u)
{
    visi[u] = 1;
    for (auto nv : edge[u])
    {
        if ((visi[nv.first] == 1))
            continue;
        node[nv.first] = (node[u] + nv.second) % 2;
        dfs(nv.first);
    }
}

ll d_to[100001] = {0};
ll d_re[100001] = {0};
vector<pair<int, int>>;  edge[from] => <to, cost>
void dijkstra(int s, ll *d)
{
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> que; //{least distancem, nodeNUm}
    fill(d, d + N + 1, INF);
    d[s] = 0;
    que.push(make_pair(0, s));

    while (!que.empty())
    {
        pair<int, int> p = que.top();
        que.pop();
        int v = p.second;
        if (d[v] < p.first)
            continue;
        for (auto nv : edge[v])
        {
            if (d[nv.first] > d[v] + nv.second)
            {
                d[nv.first] = d[v] + nv.second;
                que.push(make_pair(d[nv.first], nv.first));
            }
        }
    }
}

ll kruskal()
{
    sort(edges.begin(), edges.end(), comp);

    UnionFind Unitree(V);

    ll res = 0;
    for (auto edge : edges)
    {
        if (!Unitree.same(edge.from, edge.to))
        {
            Unitree.unite(edge.from, edge.to);
            res += edge.cost;
        }
    }
    return res;
}

bool check(ll mid)
{
    if (mid > R || mid > B)
        return false;
    ll num = (R - mid) / (x - 1) + (B - mid) / (y - 1);
    return (num >= mid);
}

BFS
  int ans = -1;
    for (int i = 0; i < H; i++)
    {
        for (int j = 0; j < W; j++)
        {
            if (map[i][j] == 0)
                continue;
            queue<pair<int, int>> q;
            q.push(make_pair(i, j));

            int ds[21][21] = {0};
            int visi[21][21] = {0};
            visi[i][j] = 1;

            while (!q.empty())
            {
                pair<int, int> now;
                now = q.front();
                q.pop();
                for (int k = 0; k < 4; k++)
                {
                    int nx = now.first + dx[k];
                    int ny = now.second + dy[k];
                    if (-1 < nx && nx < H && -1 < ny && ny < W && visi[nx][ny] == 0)
                    {
                        if (map[nx][ny])
                        {
                            ds[nx][ny] = ds[now.first][now.second] + 1;
                            visi[nx][ny] = 1;
                            q.push(make_pair(nx, ny));
                        }
                    }
                }
            }


*/


Measured memory_bytes: 256