#include <iostream>
#include <queue>

using namespace std;


struct Node
{
    int left = -1;
    int right = -1;
    int parent = -1;
};

Node* tree;
int tree_top;
Node* pattern_tree;
vector<pair<int, int>> correct_nodes_order;
int pattern_tree_top;
int last_not_changed;


void read_tree(int tree_size)
{
    for(int i = 0; i < tree_size; i++)
    {
        int parent;
        cin >> parent;
        parent--;

        if(parent == -2)
        {
            tree_top = i;
            tree[i].parent = -1;
        }
        else
        {
            tree[i].parent = parent;
            if(parent > i)
                tree[parent].left = i;
            else
                tree[parent].right = i;
        }
    }
}

void read_pattern_tree(int tree_size)
{
    for(int i = 0; i < tree_size; i++)
    {
        int parent;
        cin >> parent;
        parent--;

        if(parent == -2)
        {
            pattern_tree_top = i;
            pattern_tree[i].parent = -1;
        }
        else
        {
            pattern_tree[i].parent = parent;
            if(parent > i)
                pattern_tree[parent].left = i;
            else
                pattern_tree[parent].right = i;
        }
    }
}

int get_layer_of_node(int node)
{
//    cout<<"finding layer of "<<node + 1<<" -> ";
    int current_node = tree_top;
    int current_layer = 0;

    while (current_node != node)
    {
        if(current_node > node)
            current_node = tree[current_node].left;
        else
            current_node = tree[current_node].right;
        current_layer++;
    }
//    cout<<current_layer<<endl;
    return current_layer;
}

int find_node_with_child_at_layer(int child_id, int layer)
{
    int current_node = tree_top;
    int current_layer = 0;

    while (current_layer < layer)
    {
        if(current_node > child_id)
            current_node = tree[current_node].left;
        else
            current_node = tree[current_node].right;
        current_layer++;
    }
    return current_node;
}


long long change_sub_tree_to_right_line(int node);
long long change_sub_tree_to_left_line(int node);


long long change_sub_tree_to_right_line(int node)
{
    long long result = 0;
    if(node == -1)
        return result;
    if(tree[node].left != -1)
    {
        result += change_sub_tree_to_left_line(tree[node].left);
        result %= 1000000007;

        result += node - tree[node].parent - 1;
        result %= 1000000007;
    }
    if(tree[node].right != -1)
    {
        result += change_sub_tree_to_right_line(tree[node].right);
        result %= 1000000007;
    }

    return result;

}

long long change_sub_tree_to_left_line(int node)
{
    long long result = 0;
    if(node == -1)
        return result;
    if(tree[node].left != -1)
    {
        result += change_sub_tree_to_left_line(tree[node].left);
        result %= 1000000007;
    }
    if(tree[node].right != -1)
    {
        result += change_sub_tree_to_right_line(tree[node].right);
        result %= 1000000007;

        result += tree[node].parent - node - 1;
        result %= 1000000007;
    }

    return result;
}

long long swap_two_nodes(int node_child, int node_parent)
{
    long long result = 0;
    if(node_child > node_parent)
    {

        int child = tree[node_parent].right;
        result += change_sub_tree_to_left_line(tree[child].left);
        result += child - tree[child].parent - 1;
        result %= 1000000007;
        while(child < node_child)
        {
            child = tree[child].right;
            if(tree[child].left != -1)
            {
                result += change_sub_tree_to_left_line(tree[child].left);
                result += child - tree[child].parent - 1;
                result %= 1000000007;
            }
        }
        last_not_changed = child;
        result += node_child - node_parent;
    }
    else
    {
        int child = tree[node_parent].left;
        result += change_sub_tree_to_right_line(tree[child].right);
//        cout<<"after changing to right line: "<<result<<endl;
        result += tree[child].parent - child - 1;
        result %= 1000000007;
        while(child > node_child)
        {
            child = tree[child].left;
            if(tree[child].right != -1)
            {
                result += change_sub_tree_to_right_line(tree[child].right);
                result += tree[child].parent - child - 1;
                result %= 1000000007;
            }
        }
        result += node_parent - node_child;
        last_not_changed = child;
    }
    result %= 1000000007;

//    cout<<"changing node_child( "<<node_child<<" ) with node_parent( "<<node_parent
//    <<" and result: "<<result<<endl;
    return result;
}

void change_tree(int from, int to, int new_top)
{
//    cout<<"from:"<<from<<" to:"<<to<<" new_top:"<<new_top<<endl;
    if(new_top < to)
    {
        tree[new_top].parent = tree[to].parent;
        if(tree[new_top].parent == -1)
            tree_top = new_top;
        else
        {
            if(tree[new_top].parent > new_top)
                tree[tree[new_top].parent].left = new_top;
            else
                tree[tree[new_top].parent].right = new_top;
        }

        //--------------------------------------------------------------
        if(from == new_top)
        {
            tree[new_top].right = new_top + 1;
        }
        else
        {
            tree[new_top].right = new_top + 1;
            tree[new_top].left = new_top - 1;
            tree[from].parent = from + 1;
            tree[from].right = -1;
            for(int i = from + 1; i < new_top; i++)
            {
                tree[i].right = -1;
                tree[i].left = i - 1;
                tree[i].parent = i + 1;
            }
        }

        for(int i = new_top + 1; i < to; i++)
        {
            tree[i].parent = i - 1;
            tree[i].left = -1;
            tree[i].right = i + 1;
        }
        tree[to].parent = to - 1;
        tree[to].left = -1;
    }
    else
    {
        tree[new_top].parent = tree[to].parent;
        if(tree[new_top].parent == -1)
            tree_top = new_top;
        else
        {
            if(tree[new_top].parent > new_top)
                tree[tree[new_top].parent].left = new_top;
            else
                tree[tree[new_top].parent].right = new_top;
        }

        tree[to].parent = to + 1;
        tree[to].right = -1;

        for(int i = to + 1; i < new_top; i++)
        {
            tree[i].right = -1;
            tree[i].left = i - 1;
            tree[i].parent = i + 1;
        }
        if(new_top != from)
        {
            tree[new_top].right = new_top + 1;
            tree[from].parent = from - 1;
            tree[from].left = -1;
        }


        tree[new_top].left = new_top - 1;

        for(int i = new_top + 1; i < from; i++)
        {
            tree[i].parent = i - 1;
            tree[i].left = -1;
            tree[i].right = i + 1;
        }
    }

//    cout<<"tree top: "<<tree_top + 1<<endl;
//    for(int i = 0; i < correct_nodes_order.size(); i++)
//    {
//        cout<<"node nr "<<i + 1<<" parent: "<<tree[i].parent + 1<<" left: "<<tree[i].left + 1<<" right: "<<tree[i].right + 1<<endl;
//    }

}

long long calculate()
{
    queue<pair<int, int>> queue;
    queue.push({pattern_tree_top, 0});

    while (!queue.empty())
    {
        pair<int, int> next = queue.front();
        queue.pop();
        correct_nodes_order.push_back(next);
        if(pattern_tree[next.first].left != -1)
        {
            queue.push({pattern_tree[next.first].left, next.second + 1});
        }
        if(pattern_tree[next.first].right != -1)
            queue.push({pattern_tree[next.first].right, next.second + 1});
    }

//    for(auto & i : correct_nodes_order)
//        cout<<"vertex: "<<i.first + 1 << " at layer "<<i.second<<endl;
//
    long long result = 0;
    for(auto & i : correct_nodes_order)
    {
//        cout<<i.first<<" : "<<i.second<<endl;
        if(i.second != get_layer_of_node(i.first))
        {
            int swapping_with = find_node_with_child_at_layer(i.first, i.second);
//            cout << "swaping " <<i.first + 1 << " with " << swapping_with + 1 << "     "<<endl;
            result += swap_two_nodes(i.first, swapping_with);
//            cout << "change tree from " <<last_not_changed + 1 << " to " << swapping_with + 1 << endl;
            change_tree(last_not_changed, swapping_with, i.first);
            result %= 1000000007;
//            cout<< "    result after swapping: "<<result<<endl;
        }
    }
    return result;
}


int main()
{
    ios_base::sync_with_stdio(false);
    int tree_size;
    cin>>tree_size;

    tree = new Node[tree_size];
    pattern_tree = new Node[tree_size];

    read_tree(tree_size);
    read_pattern_tree(tree_size);

//    cout<<"tree top: "<<tree_top<<endl;
//    for(int i = 0; i < tree_size; i++)
//    {
//        cout<<"node nr "<<i<<" parent: "<<tree[i].parent<<" left: "<<tree[i].left<<" right: "<<tree[i].right<<endl;
//    }

    cout<<calculate()<<endl;
    return 0;
}