#include <bits/stdc++.h>
using namespace std;
struct matrix {
  long long mat[3][3];
  void clear() { memset(mat, -1, sizeof(mat)); }
} I;
matrix &operator*=(matrix &res, matrix b) {
  matrix a = res;
  res.clear();
  for (int i = 0; i < 3; ++i)
    for (int j = 0; j < 3; ++j)
      if (a.mat[i][j] != -1)
        for (int k = 0; k < 3; ++k)
          if (b.mat[j][k] != -1)
            res.mat[i][k] = max(res.mat[i][k], a.mat[i][j] + b.mat[j][k]);
  return res;
}
matrix operator*(matrix a, const matrix &b) { return a *= b; }
const int maxn = 30010;
struct mypair {
  long long val;
  int idx;
} a[maxn], b[maxn];
int pa[maxn], pb[maxn], w[maxn];
int n, q;
bool cmp_val(mypair a, mypair b) { return a.val < b.val; }
void init() {
  scanf("%d%d", &n, &q);
  for (int i = 1; i <= n; ++i) scanf("%I64d", &a[i].val), a[i].idx = i;
  for (int i = 1; i <= n; ++i) scanf("%I64d", &b[i].val), b[i].idx = i;
  sort(a + 1, a + n + 1, cmp_val), sort(b + 1, b + n + 1, cmp_val);
  for (int i = 1; i <= n; ++i) w[i] = pa[a[i].idx] = pb[b[i].idx] = i;
}
matrix get_matrix(int k) {
  matrix c;
  c.clear();
  c.mat[1][0] = 0, c.mat[2][1] = 0;
  if (w[a[k].idx] != b[k].idx) c.mat[2][2] = a[k].val * b[k].val;
  if (k <= 1) return c;
  if (w[a[k].idx] != b[k - 1].idx && w[a[k - 1].idx] != b[k].idx)
    c.mat[1][2] = (a[k].val * b[k - 1].val) + (a[k - 1].val * b[k].val);
  if (k <= 2) return c;
  long long v1 = -1, v2 = -1;
  if (w[a[k].idx] != b[k - 1].idx && w[a[k - 1].idx] != b[k - 2].idx &&
      w[a[k - 2].idx] != b[k].idx)
    v1 = (a[k].val * b[k - 1].val) + (a[k - 1].val * b[k - 2].val) +
         (a[k - 2].val * b[k].val);
  if (w[a[k].idx] != b[k - 2].idx && w[a[k - 1].idx] != b[k].idx &&
      w[a[k - 2].idx] != b[k - 1].idx)
    v2 = (a[k].val * b[k - 2].val) + (a[k - 1].val * b[k].val) +
         (a[k - 2].val * b[k - 1].val);
  c.mat[0][2] = max(v1, v2);
  return c;
}
struct Tsegment_tree {
  matrix t[maxn << 2];
  void build(int p, int l, int r) {
    if (l == r) {
      t[p] = get_matrix(l);
      return;
    }
    int mid = (l + r) >> 1, lc = p << 1, rc = lc | 1;
    build(lc, l, mid), build(rc, mid + 1, r);
    t[p] = t[lc] * t[rc];
  }
  void build() { build(1, 1, n); }
  void modify(int p, int l, int r, int a, int b) {
    if (l == r) {
      t[p] = get_matrix(l);
      return;
    }
    int mid = (l + r) >> 1, lc = p << 1, rc = lc | 1;
    if (a <= mid) modify(lc, l, mid, a, b);
    if (b > mid) modify(rc, mid + 1, r, a, b);
    t[p] = t[lc] * t[rc];
  }
  void modify(int l, int r) { modify(1, 1, n, l, r); }
  long long query() { return t[1].mat[2][2]; }
} seg;
void modify(int x, int y) {
  switch (pa[x] - pb[y]) {
    case -2:
      seg.modify(pa[x] + 2, pa[x] + 2);
      break;
    case -1:
      seg.modify(pa[x] + 1, pa[x] + 2);
      break;
    case 0:
      seg.modify(pa[x], pa[x]);
      break;
    case +1:
      seg.modify(pa[x], pa[x] + 1);
      break;
    case +2:
      seg.modify(pa[x], pa[x]);
      break;
  }
}
int main() {
  init();
  seg.build();
  for (int i = 1, u, v; i <= q; ++i) {
    scanf("%d%d", &u, &v), swap(w[u], w[v]);
    modify(u, w[u]), modify(u, w[v]);
    modify(v, w[v]), modify(v, w[u]);
    printf("%I64d\n", seg.query());
  }
  return 0;
}
