#include <bits/stdc++.h>
const int N = 200050;
const long long inf = 1e16;
using namespace std;
inline int gi() {
  char ch = getchar();
  int x = 0, q = 0;
  while (ch < '0' || ch > '9') ch == '-' ? q = 1 : 0, ch = getchar();
  while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
  return q ? (-x) : x;
}
struct P {
  int id;
  long long s;
  int z;
  bool operator<(const P &c) const { return s < c.s; }
} a[N], b[N];
struct seg {
  long long f[3][3];
  int id, s;
  void init(int x) {
    for (int i = 0; i < 3; ++i)
      for (int j = 0; j < 3; ++j) f[i][j] = -inf;
    f[1][0] = f[0][1] = 0;
    if (a[x].z != b[x].id) f[0][0] = a[x].s * b[x].s;
    return;
  }
} tr[N];
int g[N], p[N];
void update(int x, int l, int m, int r) {
  for (int i = 0; i < 3; ++i)
    for (int j = 0; j < 3; ++j) tr[x].f[i][j] = -inf;
  for (int i = 0; i < 3; ++i)
    for (int j = 0; j < 3; ++j)
      for (int k = 0; k < 3; ++k)
        for (int p = 0; p < 3; ++p) {
          if (j + k > 3) continue;
          if (j + k == 0)
            (tr[x].f[i][p] =
                 tr[x].f[i][p] > tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p]
                     ? tr[x].f[i][p]
                     : tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p]);
          else if (!j || !k) {
            if (k == 0 && p == r - m && j + p < 3)
              (tr[x].f[i][j + p] =
                   tr[x].f[i][j + p] >
                           tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p]
                       ? tr[x].f[i][j + p]
                       : tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p]);
            if (j == 0 && i == m - l + 1 && i + k < 3)
              (tr[x].f[i + k][p] =
                   tr[x].f[i + k][p] >
                           tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p]
                       ? tr[x].f[i + k][p]
                       : tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p]);
          } else if (j == 1 && k == 1) {
            (tr[x].f[i][p] =
                 tr[x].f[i][p] > tr[(x << 1)].f[i][j] +
                                     tr[(x << 1 | 1)].f[k][p] +
                                     a[m].s * b[m + 1].s + a[m + 1].s * b[m].s
                     ? tr[x].f[i][p]
                     : tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p] +
                           a[m].s * b[m + 1].s + a[m + 1].s * b[m].s);
          } else {
            int t1, t2, t3;
            if (j == 2)
              t1 = m - 1;
            else
              t1 = m;
            t2 = t1 + 1, t3 = t2 + 1;
            (tr[x].f[i][p] =
                 tr[x].f[i][p] > tr[(x << 1)].f[i][j] +
                                     tr[(x << 1 | 1)].f[k][p] +
                                     a[t3].s * b[t2].s + a[t2].s * b[t1].s +
                                     a[t1].s * b[t3].s
                     ? tr[x].f[i][p]
                     : tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p] +
                           a[t3].s * b[t2].s + a[t2].s * b[t1].s +
                           a[t1].s * b[t3].s);
            (tr[x].f[i][p] =
                 tr[x].f[i][p] > tr[(x << 1)].f[i][j] +
                                     tr[(x << 1 | 1)].f[k][p] +
                                     a[t3].s * b[t1].s + a[t2].s * b[t3].s +
                                     a[t1].s * b[t2].s
                     ? tr[x].f[i][p]
                     : tr[(x << 1)].f[i][j] + tr[(x << 1 | 1)].f[k][p] +
                           a[t3].s * b[t1].s + a[t2].s * b[t3].s +
                           a[t1].s * b[t2].s);
          }
        }
  return;
}
void build(int x, int l, int r) {
  if (l == r) return tr[x].init(l);
  int mid = (l + r) >> 1;
  build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
  return update(x, l, mid, r);
}
void modify(int x, int l, int r, int y) {
  if (l == r) return tr[x].init(l);
  int mid = (l + r) >> 1;
  if (y <= mid)
    modify((x << 1), l, mid, y);
  else
    modify((x << 1 | 1), mid + 1, r, y);
  return update(x, l, mid, r);
}
int main() {
  int n = gi(), q = gi(), x, y;
  for (int i = 1; i <= n; ++i) a[i] = (P){i, gi()};
  for (int i = 1; i <= n; ++i) b[i] = (P){i, gi()}, a[i].z = i;
  sort(a + 1, a + n + 1);
  sort(b + 1, b + n + 1);
  for (int i = 1; i <= n; ++i) g[a[i].id] = i;
  build(1, 1, n);
  for (int i = 1; i <= q; ++i) {
    x = g[gi()], y = g[gi()];
    swap(a[x].z, a[y].z);
    modify(1, 1, n, x);
    modify(1, 1, n, y);
    printf("%I64d\n", tr[1].f[0][0]);
  }
  return 0;
}
