#include <bits/stdc++.h>
using namespace std;
const int N = 30077;
int n, posw[N], pr[N];
pair<long long, int> w[N], h[N];
struct node {
  long long dp[3][3];
  node() { memset(dp, -1, sizeof dp); }
} T[4 * N];
inline bool can(int u, int v) { return (pr[w[u].second] != h[v].second); }
inline long long con(int u, int v) { return w[u].first * h[v].first; }
node init(int bid) {
  node ret;
  int tl = bid << 2;
  int tr = tl + 4 - 1;
  for (int l = 0; l < (3); ++l)
    for (int r = 0; r < (3); ++r) {
      int rest = 4 - l - r;
      vector<int> perm(rest);
      for (int i = 0; i < (rest); ++i) perm[i] = i;
      do {
        int s = tl + l;
        bool ok = true;
        long long cur = 0;
        for (int i = 0; i < (rest); ++i) {
          int j = perm[i];
          int u = s + i;
          int v = s + j;
          ok &= can(u, v);
          cur += con(u, v);
        }
        if (ok) ret.dp[l][r] = max(ret.dp[l][r], cur);
      } while (next_permutation((perm).begin(), (perm).end()));
    }
  return ret;
}
node combine(int tl, int tr, const node &A, const node &B) {
  int tm = (tl + tr) / 2;
  tl = 4 * tl;
  tr = 4 * (tr + 1) - 1;
  tm = 4 * (tm + 1) - 1;
  node ret;
  for (int l = 0; l < (3); ++l)
    for (int r = 0; r < (3); ++r) {
      long long &dp = ret.dp[l][r];
      if (A.dp[l][0] != -1 && B.dp[0][r] != -1)
        dp = max(dp, A.dp[l][0] + B.dp[0][r]);
      if (A.dp[l][1] != -1 && B.dp[1][r] != -1) {
        if (can(tm, tm + 1) && can(tm + 1, tm))
          dp = max(dp,
                   A.dp[l][1] + B.dp[1][r] + con(tm, tm + 1) + con(tm + 1, tm));
      }
      if (A.dp[l][1] != -1 && B.dp[2][r] != -1) {
        if (can(tm, tm + 2) && can(tm + 1, tm) && can(tm + 2, tm + 1))
          dp = max(dp, A.dp[l][1] + B.dp[2][r] + con(tm, tm + 2) +
                           con(tm + 1, tm) + con(tm + 2, tm + 1));
        if (can(tm, tm + 1) && can(tm + 1, tm + 2) && can(tm + 2, tm))
          dp = max(dp, A.dp[l][1] + B.dp[2][r] + con(tm, tm + 1) +
                           con(tm + 1, tm + 2) + con(tm + 2, tm));
      }
      if (A.dp[l][2] != -1 && B.dp[1][r] != -1) {
        if (can(tm - 1, tm + 1) && can(tm, tm - 1) && can(tm + 1, tm))
          dp = max(dp, A.dp[l][2] + B.dp[1][r] + con(tm - 1, tm + 1) +
                           con(tm, tm - 1) + con(tm + 1, tm));
        if (can(tm - 1, tm) && can(tm, tm + 1) && can(tm + 1, tm - 1))
          dp = max(dp, A.dp[l][2] + B.dp[1][r] + con(tm - 1, tm) +
                           con(tm, tm + 1) + con(tm + 1, tm - 1));
      }
    }
  return ret;
}
void build(int v, int tl, int tr) {
  if (tl == tr) {
    T[v] = init(tl);
    return;
  }
  int tm = (tl + tr) / 2;
  build(2 * v, tl, tm);
  build(2 * v + 1, tm + 1, tr);
  T[v] = combine(tl, tr, T[2 * v], T[2 * v + 1]);
}
void _update(int v, int tl, int tr, int bid) {
  if (tl == tr) {
    T[v] = init(bid);
    return;
  }
  int tm = (tl + tr) / 2;
  if (bid <= tm)
    _update(2 * v, tl, tm, bid);
  else
    _update(2 * v + 1, tm + 1, tr, bid);
  T[v] = combine(tl, tr, T[2 * v], T[2 * v + 1]);
}
void update(int u) { _update(1, 0, (n >> 2) - 1, posw[u] >> 2); }
long long answer() { return T[1].dp[0][0]; }
void solve() {
  int q;
  scanf("%d%d", &n, &q);
  for (int i = 0; i < (n); ++i) {
    scanf("%lld", &w[i].first);
    w[i].second = i;
  }
  for (int i = 0; i < (n); ++i) {
    scanf("%lld", &h[i].first);
    h[i].second = i;
  }
  for (int i = 0; i < (n); ++i) pr[i] = i;
  while (n % 4 != 0) {
    w[n] = make_pair(0, n);
    h[n] = make_pair(-(1LL << 30), n);
    pr[n] = -1;
    n++;
  }
  sort(w, w + n);
  sort(h, h + n);
  for (int i = 0; i < (n); ++i) {
    posw[w[i].second] = i;
  }
  build(1, 0, (n >> 2) - 1);
  while (q--) {
    int u, v;
    scanf("%d%d", &u, &v);
    --u, --v;
    swap(pr[u], pr[v]);
    update(u);
    update(v);
    printf("%lld\n", answer());
  }
}
void testGen() {
  FILE *f = fopen("input.txt", "w");
  fclose(f);
}
int main() {
  cerr << fixed;
  cerr.precision(3);
  cout << fixed;
  cout.precision(9);
  solve();
  return 0;
}
