description: You are given two arrays of integers a_1, a_2, …, a_n and b_1, b_2, …, b_m.
  
  You need to insert all elements of b into a in an arbitrary way. As a result you will get an array c_1, c_2, …, c_{n+m} of size n + m.
  
  Note that you are not allowed to change the order of elements in a, while you can insert elements of b at arbitrary positions. They can be inserted at the beginning, between any elements of a, or at the end. Moreover, elements of b can appear in the resulting array in any order.
  
  What is the minimum possible number of inversions in the resulting array c? Recall that an inversion is a pair of indices (i, j) such that i < j and c_i > c_j.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
  
  The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 10^6).
  
  The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
  
  The third line of each test case contains m integers b_1, b_2, …, b_m (1 ≤ b_i ≤ 10^9).
  
  It is guaranteed that the sum of n for all tests cases in one input doesn't exceed 10^6. The sum of m for all tests cases doesn't exceed 10^6 as well.
  
  Output
  
  For each test case, print one integer — the minimum possible number of inversions in the resulting array c.
  
  Example
  
  Input
  
  
  3
  3 4
  1 2 3
  4 3 2 1
  3 3
  3 2 1
  1 2 3
  5 4
  1 3 5 3 1
  4 3 6 1
  
  
  Output
  
  
  0
  4
  6
  
  Note
  
  Below is given the solution to get the optimal answer for each of the example test cases (elements of a are underscored).
  
    * In the first test case, c = [\underline{1}, 1, \underline{2}, 2, \underline{3}, 3, 4]. 
    * In the second test case, c = [1, 2, \underline{3}, \underline{2}, \underline{1}, 3]. 
    * In the third test case, c = [\underline{1}, 1, 3, \underline{3}, \underline{5}, \underline{3}, \underline{1}, 4, 6]. 
solution: #include <bits/stdc++.h>
  using namespace std;
  const int maxn = 2500020;
  const int maxm = 10000020;
  const int MOd = 998244353;
  int a, b, ar[maxn], bs[maxn], sz[maxn];
  int n, segment[maxn * 2], lazy[maxn * 2];
  vector<int> w[maxn], v;
  void push(int k) {
    if (lazy[k]) {
      if (k < n) {
        lazy[k + k] += lazy[k];
        lazy[k + k + 1] += lazy[k];
      }
      segment[k] += lazy[k];
      lazy[k] = 0;
    }
  }
  void up(int k, int b, int s, int x, int y, int m) {
    push(k);
    if (b > y || x > s) return;
    if (x <= b && s <= y) {
      lazy[k] += m;
      push(k);
      return;
    }
    up(k + k, b, (b + s) / 2, x, y, m);
    up(k + k + 1, (b + s) / 2 + 1, s, x, y, m);
    segment[k] = min(segment[k + k], segment[k + k + 1]);
  }
  int fw[maxn], cnt;
  int find(int x) {
    int ret = 0;
    for (int i = x; i <= cnt; i += i & (-i)) ret += fw[i];
    return ret;
  }
  void fup(int x) {
    for (int i = x; i > 0; i -= i & (-i)) fw[i] += 1;
  }
  void solve() {
    scanf("%d %d", &a, &b);
    v.clear();
    for (int i = 1; i <= a; i++) scanf("%d", &ar[i]), v.push_back(ar[i]);
    for (int i = 1; i <= b; i++) scanf("%d", &bs[i]), v.push_back(bs[i]);
    sort(v.begin(), v.end());
    v.erase(unique(v.begin(), v.end()), v.end());
    cnt = v.size();
    n = 1;
    while (n < a + 1) n <<= 1;
    for (int i = 1; i <= n + n; i++) segment[i] = lazy[i] = 0;
    for (int i = 0; i <= cnt; i++) fw[i] = 0, sz[i] = 0;
    for (int i = 1; i <= a; i++)
      ar[i] = lower_bound(v.begin(), v.end(), ar[i]) - v.begin() + 1;
    for (int i = 1; i <= b; i++)
      bs[i] = lower_bound(v.begin(), v.end(), bs[i]) - v.begin() + 1, sz[bs[i]]++;
    for (int i = 1; i <= a; i++) w[ar[i]].push_back(i);
    for (int i = n + n - 1; i >= 1; i--) {
      if (i >= n)
        segment[i] = min(a, i - n);
      else
        segment[i] = min(segment[i + i], segment[i + i + 1]);
    }
    long long ans = 0;
    for (int i = 1; i <= a; i++) {
      ans += find(ar[i] + 1);
      fup(ar[i]);
    }
    for (int i = 1; i <= cnt; i++) {
      for (int j = 0; j < w[i].size(); j++) up(1, 1, n, w[i][j] + 1, n, -1);
      push(1);
      ans += (long long)segment[1] * sz[i];
      for (int j = 0; j < w[i].size(); j++) up(1, 1, n, 1, w[i][j], 1);
    }
    cout << ans << endl;
    for (int i = 1; i <= cnt; i++) w[i].clear();
  }
  int main() {
    int n = 1;
    scanf("%d", &n);
    while (n--) solve();
    return 0;
  }
  