Pavel cooks barbecue. There are n skewers, they lay on a brazier in a row, each on one of n positions. Pavel wants each skewer to be cooked some time in every of n positions in two directions: in the one it was directed originally and in the reversed direction.

Pavel has a plan: a permutation p and a sequence b1, b2, ..., bn, consisting of zeros and ones. Each second Pavel move skewer on position i to position pi, and if bi equals 1 then he reverses it. So he hope that every skewer will visit every position in both directions.

Unfortunately, not every pair of permutation p and sequence b suits Pavel. What is the minimum total number of elements in the given permutation p and the given sequence b he needs to change so that every skewer will visit each of 2n placements? Note that after changing the permutation should remain a permutation as well.

There is no problem for Pavel, if some skewer visits some of the placements several times before he ends to cook. In other words, a permutation p and a sequence b suit him if there is an integer k (k ≥ 2n), so that after k seconds each skewer visits each of the 2n placements.

It can be shown that some suitable pair of permutation p and sequence b exists for any n.

Input

The first line contain the integer n (1 ≤ n ≤ 2·105) — the number of skewers.

The second line contains a sequence of integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation, according to which Pavel wants to move the skewers.

The third line contains a sequence b1, b2, ..., bn consisting of zeros and ones, according to which Pavel wants to reverse the skewers.

Output

Print single integer — the minimum total number of elements in the given permutation p and the given sequence b he needs to change so that every skewer will visit each of 2n placements.

Examples

Input

4
4 3 2 1
0 1 1 1


Output

2


Input

3
2 3 1
0 0 0


Output

1

Note

In the first example Pavel can change the permutation to 4, 3, 1, 2.

In the second example Pavel can change any element of b to 1.
import java.util.*;

public class Barbecue {
    public static class Graph
    {
        public int V;
        ArrayList<Integer> adjList[];
  
        public Graph(int V)
        {
            this.V = V;
            adjList = new ArrayList[V];

            for(int i = 0; i < V ; i++){
                adjList[i] = new ArrayList<Integer>();
            }
        }
        public void addEdge(int src, int dest, boolean bidirectional)
        {
            this.adjList[src].add(dest);
            if (bidirectional) {
            	this.adjList[dest].add(src);
            }
        }
        public void printGraph()
        {       
            for(int v = 0; v < this.V; v++)
            {
                System.out.println("Vertex "+ v + ":");
                System.out.print("Conntected to ");
                for(Integer pCrawl: this.adjList[v]){
                    System.out.print(pCrawl + " ");
                }
                System.out.println("\n");
            }
        }
        public boolean dfs(int s, boolean[] visited, boolean[] recStack) {
        	if (recStack[s]) return true;
        	if (visited[s]) return false;
        	
    		visited[s] = true;
    		recStack[s] = true;
    		//process
    		for (int u: adjList[s]) {
    			if (dfs(u,visited, recStack)) {
    				return true;
    			}
    		}
	    	recStack[s] = false;
    		return false;
        }
    }

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int[] p = new int[n];
		boolean[] visited = new boolean[n];
		boolean[] recStack = new boolean[n];
		
		int oneCount = 0;
		
		for (int i = 0; i<n; i++) {
			p[i] = input.nextInt()-1;
		}
		for (int i = 0; i<n; i++) {
			if (input.nextInt()==1) oneCount++;
		}
		
		int cycleCount = 0;
		
		
		Graph g = new Graph(n);
		
		for (int i = 0; i<n; i++) {
			g.addEdge(i, p[i], false);
		}

		for (int i = 0; i<n; i++) {
			if (visited[i]==true) continue;
			else {
				if (g.dfs(i, visited, recStack)) cycleCount++;
			}
		}
		if (cycleCount==1) {
			System.out.println(Math.abs(1-oneCount%2));
		}
		else {
			System.out.println(cycleCount+Math.abs(1-oneCount%2));
		}
	}

}
