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

#include <bits/stdc++.h>
using namespace std;
int const N = 200000;
int n;
int a[N], b[N], c[N];
map<int, int> fa, fb, fc;
void prepare() {
  for (int i = 1; i <= n; ++i) {
    if (fa.count(a[i]) == 0) {
      fa[a[i]] = i;
    }
    if (fb.count(b[i]) == 0) {
      fb[b[i]] = i;
    }
    if (fc.count(c[i]) == 0) {
      fc[c[i]] = i;
    }
  }
}
set<pair<int, int> > table;
inline void maintain(int x, int y) {
  if (table.count(make_pair(x, -y)) > 0) {
    return;
  }
  if (!table.empty()) {
    set<pair<int, int> >::iterator it = table.lower_bound(make_pair(x, -y));
    if (it == table.end()) {
      it--;
    }
    while (-(it->second) <= y) {
      int x0 = it->first;
      int y0 = it->second;
      if (it == table.begin()) {
        table.erase(make_pair(x0, y0));
        break;
      } else {
        it--;
        table.erase(make_pair(x0, y0));
      }
    }
  }
  table.insert(make_pair(x, -y));
}
inline int get(int min_a, int min_b) {
  if (table.empty()) {
    return min_a + min_b;
  } else {
    int ans = n + n + 2;
    ans = min(ans, min_a + max(min_b, -table.begin()->second));
    ans = min(ans, max(min_a, table.rbegin()->first) + min_b);
    return ans;
  }
}
inline void solve() {
  int min_a = 0, min_b = 0;
  for (int i = 1; i <= n; ++i) {
    if (i == fa[a[i]]) {
      if (fc.count(a[i]) == 0) {
        if (fb.count(a[i]) > 0) {
          maintain(i, fb[a[i]]);
        } else {
          min_a = max(min_a, i);
        }
      }
    }
    if (i == fb[b[i]]) {
      if (fc.count(b[i]) == 0) {
        if (fa.count(b[i]) > 0) {
          maintain(fa[b[i]], i);
        } else {
          min_b = max(min_b, i);
        }
      }
    }
  }
  int ans = n + n + n;
  for (int i = n; i >= 1; --i) {
    if (i == fc[c[i]]) {
      ans = min(ans, i + get(min_a, min_b));
      if (fa.count(c[i]) > 0 && fb.count(c[i]) > 0) {
        maintain(fa[c[i]], fb[c[i]]);
      } else if (fa.count(c[i]) > 0) {
        min_a = max(min_a, fa[c[i]]);
      } else if (fb.count(c[i]) > 0) {
        min_b = max(min_b, fb[c[i]]);
      } else {
        break;
      }
    }
  }
  printf("%d\n", ans);
}
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", a + i);
  }
  for (int i = 1; i <= n; ++i) {
    scanf("%d", b + i);
  }
  for (int i = 1; i <= n; ++i) {
    scanf("%d", c + i);
  }
  prepare();
  solve();
  return 0;
}
