#include <bits/stdc++.h>
using namespace std;
void merge(int arr[], int l, int m, int r) {
  int i, j, k;
  int n1 = m - l + 1;
  int n2 = r - m;
  int L[n1];
  int R[n2];
  for (i = 0; i < n1; i++) {
    L[i] = arr[l + i];
  }
  for (j = 0; j < n2; j++) {
    R[j] = arr[m + 1 + j];
  }
  i = 0;
  j = 0;
  k = l;
  while (i < n1 && j < n2) {
    if (L[i] <= R[j]) {
      arr[k] = L[i];
      i++;
    } else {
      arr[k] = R[j];
      j++;
    }
    k++;
  }
  while (i < n1) {
    arr[k] = L[i];
    i++;
    k++;
  }
  while (j < n2) {
    arr[k] = R[j];
    j++;
    k++;
  }
}
void mergeSort(int arr[], int l, int r) {
  if (l < r) {
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
  }
}
int main() {
  int tests, n, k, ntests;
  cin >> tests;
  for (ntests = 0; ntests < tests; ntests++) {
    int nswaps = 0, i = 0, j = 0, totalA = 0;
    cin >> n >> k;
    int arrA[n], arrB[n];
    for (int i = 0; i < n; i++) {
      cin >> arrA[i];
    }
    for (int i = 0; i < n; i++) {
      cin >> arrB[i];
    }
    mergeSort(arrA, 0, n - 1);
    mergeSort(arrB, 0, n - 1);
    i = 0;
    j = n - 1;
    for (int nswaps = 0; nswaps < k; nswaps++) {
      if (arrA[i] < arrB[j]) {
        arrA[i] = arrB[j];
        i++, j--;
      } else
        nswaps = k;
    }
    for (int i = 0; i < n; i++) {
      totalA += arrA[i];
    }
    cout << totalA << endl;
  }
}

### Prompt

Generate a cpp solution to the following problem:

You are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.

In one move, you can choose two indices i and j (1 ≤ i, j ≤ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).

Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.

The first line of the test case contains two integers n and k (1 ≤ n ≤ 30; 0 ≤ k ≤ n) — the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 30), where b_i is the i-th element of b.

Output

For each test case, print the answer — the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.

Example

Input


5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4


Output


6
27
39
11
17

Note

In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].

In the second test case of the example, you don't need to swap anything.

In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].

In the fourth test case of the example, you cannot swap anything.

In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1].

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
void merge(int arr[], int l, int m, int r) {
  int i, j, k;
  int n1 = m - l + 1;
  int n2 = r - m;
  int L[n1];
  int R[n2];
  for (i = 0; i < n1; i++) {
    L[i] = arr[l + i];
  }
  for (j = 0; j < n2; j++) {
    R[j] = arr[m + 1 + j];
  }
  i = 0;
  j = 0;
  k = l;
  while (i < n1 && j < n2) {
    if (L[i] <= R[j]) {
      arr[k] = L[i];
      i++;
    } else {
      arr[k] = R[j];
      j++;
    }
    k++;
  }
  while (i < n1) {
    arr[k] = L[i];
    i++;
    k++;
  }
  while (j < n2) {
    arr[k] = R[j];
    j++;
    k++;
  }
}
void mergeSort(int arr[], int l, int r) {
  if (l < r) {
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
  }
}
int main() {
  int tests, n, k, ntests;
  cin >> tests;
  for (ntests = 0; ntests < tests; ntests++) {
    int nswaps = 0, i = 0, j = 0, totalA = 0;
    cin >> n >> k;
    int arrA[n], arrB[n];
    for (int i = 0; i < n; i++) {
      cin >> arrA[i];
    }
    for (int i = 0; i < n; i++) {
      cin >> arrB[i];
    }
    mergeSort(arrA, 0, n - 1);
    mergeSort(arrB, 0, n - 1);
    i = 0;
    j = n - 1;
    for (int nswaps = 0; nswaps < k; nswaps++) {
      if (arrA[i] < arrB[j]) {
        arrA[i] = arrB[j];
        i++, j--;
      } else
        nswaps = k;
    }
    for (int i = 0; i < n; i++) {
      totalA += arrA[i];
    }
    cout << totalA << endl;
  }
}

```