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;
const long long inf = 1e18;
long long n, ipt[100005][3];
vector<long long> cpr;
vector<pair<long long, pair<long long, long long> > > lifetime;
set<pair<long long, long long> > st;
map<pair<long long, long long>, long long> sp;
struct triplet {
  long long x, y, z;
  bool operator<(const triplet &A) const { return z > A.z; }
} coor[300005];
struct segtree {
  long long val[2000005], lim;
  void init(long long N) {
    for (lim = 1; lim <= N; lim <<= 1)
      ;
    for (int i = 2 * lim; --i;) val[i] = inf;
  }
  void update(long long S, long long E, long long V) {
    S += lim;
    E += lim;
    while (S <= E) {
      if (S % 2 == 1) val[S] = min(val[S], V), S++;
      if (E % 2 == 0) val[E] = min(val[E], V), E--;
      S >>= 1;
      E >>= 1;
    }
  }
  long long query(long long P) {
    long long ret = inf;
    P += lim;
    while (P) {
      ret = min(ret, val[P]);
      P >>= 1;
    }
    return ret;
  }
} seg;
int main() {
  scanf("%lld", &n);
  for (int k = 0; k < 3; k++)
    for (int i = 1; i <= n; i++) {
      scanf("%lld", &ipt[i][k]);
      cpr.push_back(ipt[i][k]);
    }
  sort(cpr.begin(), cpr.end());
  cpr.erase(unique(cpr.begin(), cpr.end()), cpr.end());
  for (int i = 0; i < cpr.size(); i++) {
    coor[i].x = inf;
    coor[i].y = inf;
    coor[i].z = inf;
  }
  for (int i = 1; i <= n; i++) {
    for (int k = 0; k < 3; k++) {
      ipt[i][k] = lower_bound(cpr.begin(), cpr.end(), ipt[i][k]) - cpr.begin();
    }
    coor[ipt[i][0]].x = min(coor[ipt[i][0]].x, 1ll * i);
    coor[ipt[i][1]].y = min(coor[ipt[i][1]].y, 1ll * i);
    coor[ipt[i][2]].z = min(coor[ipt[i][2]].z, 1ll * i);
  }
  sort(coor, coor + ((int)cpr.size()));
  st.insert({0, inf});
  st.insert({inf, 0});
  for (int i = 0; i < cpr.size(); i++) {
    st.insert({coor[i].x, coor[i].y});
    {
      auto it = st.find({coor[i].x, coor[i].y});
      auto nxt = it;
      nxt++;
      auto prv = it;
      prv--;
      if ((nxt->second) > coor[i].y) {
        st.erase({coor[i].x, coor[i].y});
        continue;
      }
      pair<long long, long long> xyp = {prv->first, nxt->second};
      lifetime.push_back({xyp.first + xyp.second, {sp[xyp], i}});
    }
    while (true) {
      auto it = st.find({coor[i].x, coor[i].y});
      auto prv = it;
      prv--;
      if ((prv->second) < coor[i].y) {
        auto pp = prv;
        pp--;
        pair<long long, long long> xyp = {pp->first, prv->second};
        lifetime.push_back({xyp.first + xyp.second, {sp[xyp], i}});
        st.erase(prv);
      } else
        break;
    }
    auto it = st.find({coor[i].x, coor[i].y});
    auto nxt = it;
    nxt++;
    auto prv = it;
    prv--;
    sp[{it->first, nxt->second}] = i + 1;
    sp[{prv->first, it->second}] = i + 1;
  }
  for (auto it = st.begin();; it++) {
    auto nxt = it;
    nxt++;
    if (nxt == st.end()) break;
    pair<long long, long long> xyp = {it->first, nxt->second};
    lifetime.push_back({xyp.first + xyp.second, {sp[xyp], cpr.size()}});
  }
  seg.init(cpr.size());
  for (int i = 0; i < lifetime.size(); i++) {
    seg.update(lifetime[i].second.first, lifetime[i].second.second,
               lifetime[i].first);
  }
  long long ans = inf;
  for (int i = 0; i <= cpr.size(); i++) {
    ans = min(ans, coor[i].z + seg.query(i));
  }
  printf("%lld", ans);
}
