#include<bits/stdc++.h>
using namespace std;
#define me(a,x) memset(a,x,sizeof(a))
#define sc scanf
#define pr printf
#define IN freopen("in.txt","r",stdin);
#define OUT freopen("out.txt","w",stdout);
typedef long long ll;
typedef unsigned long long ull;
const int N=1e6+6;
const int mod=1e9+7;
int O(){putchar('\n');return 0;}template<typename T,typename... Ty>
int O(const T& a,const Ty&... b){cout<<a<<' ';return O(b...);}
void I(){}template<typename T,typename... Ty>void I(T& a,Ty&... b){cin>>a;I(b...);}
template<typename T>void db(T *bg,T *ed){while(bg!=ed)cout<<*bg++<<' ';pr("\n");}
inline ll mul_64(ll x,ll y,ll c){return (x*y-(ll)((long double)x/c*y)*c+c)%c;}
inline ll ksm(ll a,ll b,ll c){ll ans=1;for(;b;b>>=1,a=a*a%c)if(b&1)ans=ans*a%c;return ans;}
int n,a[20],b[20];
int dp[1<<20][20];
const int INF=1e9;
int main(){
    I(n);
    for(int i=0;i<n;i++)sc("%d",&a[i]);
    for(int i=0;i<n;i++)sc("%d",&b[i]);
    for(int i=1;i<n;i+=2)swap(a[i],b[i]);
    for(int i=0;i<(1<<n);i++){
        for(int j=0;j<n;j++){
            dp[i][j]=INF; // 不可达
        }
    }
    for(int i=0;i<n;i++)dp[1<<i][i]=0; // 选单个 逆序对为0
    for(int i=0;i<(1<<n);i++){ // 保证子状态先于父状态计算
        for(int j=0;j<n;j++){
            if(dp[i][j]==INF)continue;
            for(int k=0;k<n;k++){
                if(i>>k&1)continue;
                int x=__builtin_popcount(i)&1; // 内置计算1的个数
                if(x){ // 非减 限制
                    if(b[k]<a[j])continue;
                }else{
                    if(a[k]<b[j])continue;
                }
                int ans=0;
                for(int l=k+1;l<n;l++){ // 计算 state补上k以后 state与k之间新形成的逆序对
                    if(i>>l&1)ans++;
                }
                dp[i|1<<k][k]=min(dp[i|1<<k][k],dp[i][j]+ans); // 递推感觉局部最小性有点奇怪？只有我？但是从上向下看是没问题的。所以逻辑一致没问题
            }
        }
    }
    int ans=INF;
    for(int i=0;i<n;i++)ans=min(ans,dp[(1<<n)-1][i]);
    if(ans==INF)O(-1);
    else O(ans);
}

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
#define INF 0x3f3f3f3f3f3f3f3f
#define MOD 1000000007
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define foreach(i, v) for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++ i)
const double pi = acos(-1.0);

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<int> d(m);
  for (int i = 0; i < m; i++) {
    cin >> d[i];
  }
  sort(d.begin(), d.end());
  int g, r;
  cin >> g >> r;
  // dist[0->m-1][0->g] = -1; 不可达
  // dist[第i个停靠点][还要走j步为g的整数倍] = 最小的完整轮数
  vector<vector<int>> dist(m, vector<int>(g + 1, -1));
  dist[0][g] = 0; // 可达的轮数为0
  vector<pair<int, int>> que;
  que.emplace_back(0, g);
  while (!que.empty()) {
    // 步数少于等于g的广搜
    for (int b = 0; b < (int) que.size(); b++) {
      int i = que[b].first; // 位置
      int j = que[b].second; // 剩余步数
      if (i > 0) { //
        int go = d[i] - d[i - 1];
        if (j >= go) {
          if (dist[i - 1][j - go] == -1) {
            que.emplace_back(i - 1, j - go);
            dist[i - 1][j - go] = dist[i][j];
          }
        }
      }
      if (i < m - 1) {
        int go = d[i + 1] - d[i];
        if (j >= go) {
          if (dist[i + 1][j - go] == -1) {
            que.emplace_back(i + 1, j - go);
            dist[i + 1][j - go] = dist[i][j];
          }
        }
      }
    }
    vector<pair<int, int>> new_que;
    // 利用g表示 上一层节点，0表示新走到的节点， 产生新的一层
    for (int b = 0; b < (int) que.size(); b++) {
      int j = que[b].second;
      if (j == 0) { // 新走道德合法点
        int i = que[b].first;
        if (dist[i][g] == -1) {
          dist[i][g] = dist[i][0] + 1; // 轮次+1
          new_que.emplace_back(i, g);
        }
      }
    }
    swap(que, new_que);
  }
  const long long inf = (long long) 1e18;
  long long ans = inf;
  for (int i = 0; i <= g; i++) {
    if (dist[m - 1][i] != -1) { // 可达到 最后一个点一定是终点
      long long cur = (long long) dist[m - 1][i] * (g + r) + (g - i); //计算总时间
      ans = min(ans, cur);
    }
  }
  cout << (ans == inf ? -1 : ans) << '\n';
  return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
#define rep(i,a,n) for (int i=a;i<n;i++)

struct State {
  State * link; // 后缀父状态 指向比它短的后缀状态
  unordered_map<int, State *> next; // 状态转移, 指向string尾部增加int后得到的State
  int maxLen; // maxlen in this state
  State(int _maxLen):
    link(NULL),maxLen(_maxLen){
      next = {};
    }
};

class SAM{
  State *root , *lastState;
public:
  SAM(){
    root = lastState = new State(0);
  }
  void extend(int w){ // ???? => ????w
    State *p = lastState;
    State *newState = new State(p->maxLen + 1);
    // find first p in lastState->link->link->link...->link
    //  satisfy p->next[w] exist
    //  let q = p->next[w]
    //  找到有 w 转移的, 或者增加w转移
    for(;p && !p->next[w];p=p->link) p->next[w] = newState;
    for(;;){ // 降低层级
      if(!p){ // 全部原来都没有w转移, 也就是 [...??w] 唯一存在
        newState -> link = root;
        break;
      }
      // state p + char w -> state q
      State *q = p->next[w]; // 说明 [p w] 至少两处存在
      if(p->maxLen+1 == q->maxLen){ // 单独状态
        newState->link = q; // newState 一定比 q 长, q是比它短的最长后缀
        break;
      }
      // clone q next & link
      State * qClone = new State(p->maxLen+1); // 相当于从State q中拆出不大于p->next[w]转移的部分
      qClone->next = q->next; // copy
      qClone->link = q->link;
      // change q & newState link
      for(;p && p->next[w] == q;p=p->link) p->next[w] = qClone; // 更新所有单独
      q->link = newState->link = qClone;
      break;
    }
    lastState = newState;
  }

  bool has(string s){
    State *p = root;
    for(auto ch:s){
      if(!p->next[ch])return false;
      p = p->next[ch];
    }
    return true;
  }
};

int main(){
  auto sam = SAM();
  string s = "aabab";
  for(auto ch: s){
    sam.extend(ch);
  }
  printf("%d\n",(int)sam.has("aba"));
  return 0;
}