There are three arrays a, b and c. Each of them consists of n integers. SmallY wants to find three integers u, v, w (0 ≤ u, v, w ≤ n) such that the following condition holds: each number that appears in the union of a, b and c, appears either in the first u elements of a, or in the first v elements of b, or in the first w elements of c. Of course, SmallY doesn't want to have huge numbers u, v and w, so she wants sum u + v + w to be as small as possible.

Please, help her to find the minimal possible sum of u + v + w.

Input

The first line contains a single integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers a1, a2, ..., an — array a. The third line contains the description of array b in the same format. The fourth line contains the description of array c in the same format. The following constraint holds: 1 ≤ ai, bi, ci ≤ 109.

Output

Print a single integer — the minimum possible sum of u + v + w.

Examples

Input

3
1 1 101
1 2 1
3 2 1


Output

5

Input

5
1 1 2 2 3
2 2 4 3 3
3 3 1 1 1


Output

5

Note

In the first example you should choose u = 3, v = 0, w = 2. 

In the second example you should choose u = 1, v = 3, w = 1.
1
2
3
2
 8
190409007 190409007 352375776 190409007 352375776 352375776 352375776 352375776
190409007 190409007 190409007 190409007 190409007 352375776 352375776 190409007
190409007 352375776 352375776 190409007 190409007 190409007 352375776 352375776
 1
1
1
1
 1
377489979
588153796
588153796
 2
1 1
2 2
3 3
 4
1 1 1 1
1 1 1 1
1 1 1 1
 2
1 2
2 2
1 1
 3
1 1 2
1 1 3
1 1 4

2
 2
 1
 2
 3
 1
 2
 9

import java.util.*;
import java.util.stream.*;

public class Solution {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		Map<Integer, Integer> aMinIndex = new HashMap<>();
		Map<Integer, Integer> bMinIndex = new HashMap<>();
		Map<Integer, Integer> cMinIndex = new HashMap<>();
		
		fillMinIndex(aMinIndex, n, s);
		fillMinIndex(bMinIndex, n, s);
		fillMinIndex(cMinIndex, n, s);
		
		//System.out.println("aMinIndex = " + convertWithStream(aMinIndex));
		//System.out.println("bMinIndex = " + convertWithStream(bMinIndex));
		//System.out.println("cMinIndex = " + convertWithStream(cMinIndex));
		
		Set<Integer> allNums = new HashSet<>();
		allNums.addAll(aMinIndex.keySet());
		allNums.addAll(bMinIndex.keySet());
		allNums.addAll(cMinIndex.keySet());
		
		Map<NumInfo, Set<String>> minArrAlpha = new HashMap<>();
		Map<NumInfo, Set<String>> minArrBeta = new HashMap<>();
		
		for(Integer num : allNums) {
			int aInd = (aMinIndex.containsKey(num)) ? aMinIndex.get(num) : (n+1);
			int bInd = (bMinIndex.containsKey(num)) ? bMinIndex.get(num) : (n+1);
			int cInd = (cMinIndex.containsKey(num)) ? cMinIndex.get(num) : (n+1);
			
			int minInd = Math.min(Math.min(aInd, bInd), cInd);
			NumInfo numInfo = new NumInfo(num, minInd);
			Set<String> arrs = new HashSet<>();
			if(aInd == minInd) arrs.add("a");
			if(bInd == minInd) arrs.add("b");
			if(cInd == minInd) arrs.add("c");
			if(arrs.size() == 1) {
				minArrAlpha.put(numInfo, arrs);
			} else {
				minArrBeta.put(numInfo, arrs);
			}
			//System.out.println(numInfo + " : " + Arrays.toString(arrs.toArray()));
		}
		
		for(Map.Entry<NumInfo, Set<String>> alpha : minArrAlpha.entrySet()) {
			String arr = alpha.getValue().iterator().next();
			for(Map.Entry<NumInfo, Set<String>> beta : minArrBeta.entrySet()) {
				if(beta.getValue().contains(arr)) {
					Set<String> oneArr = new HashSet<>();
					oneArr.add(arr);
					minArrBeta.put(beta.getKey(), oneArr);
				}
			}
		}
		
		Map<String, Integer> minArr = new HashMap<>();
		fillResult(minArrAlpha, minArr);
		fillResult(minArrBeta, minArr);
		
		int u = (minArr.containsKey("a")) ? minArr.get("a") + 1 : 0;
		int v = (minArr.containsKey("b")) ? minArr.get("b") + 1 : 0;
		int w = (minArr.containsKey("c")) ? minArr.get("c") + 1 : 0;
		
		System.out.println(u+v+w);
	}	
	
	private static void fillMinIndex(Map<Integer, Integer> minIndex, int n, Scanner s) {
		for(int i = 0; i < n; i++) {
			int num = s.nextInt();
			if(!minIndex.containsKey(num)) {
				minIndex.put(num, i);
			} 
		}
	}
	
	private static void fillResult(Map<NumInfo, Set<String>> minArrLetter, Map<String, Integer> minArr) {
		for(Map.Entry<NumInfo, Set<String>> elem : minArrLetter.entrySet()) {
			String arr = elem.getValue().iterator().next();
			int index = elem.getKey().index;
			if(!minArr.containsKey(arr)) {
				minArr.put(arr, index);
			} else {
				minArr.put(arr, Math.max(index, minArr.get(arr)));
			}
		}
	}
	
	public static String convertWithStream(Map<?, ?> map) {
		String mapAsString = map.keySet().stream()
		  .map(key -> key + "=" + map.get(key))
		  .collect(Collectors.joining(", ", "{", "}"));
		return mapAsString;
	}
}

class NumInfo {
	int num;
	int index;
	
	public NumInfo(int num, int index) {
		this.num = num;
		this.index = index;
	}
	
	public boolean equals(Object o) {
		if(!(o instanceof NumInfo)) return false;
		NumInfo other = (NumInfo) o;
		return other.num == num && other.index == index;
	}
	
	public int hashCode() {
		return 31*num + index;
	}
	
	public String toString() {
		return "(" + num + ", " + index + ")";
	}
}