Consider a sequence of integers a_1, a_2, …, a_n. In one move, you can select any element of the sequence and delete it. After an element is deleted, all elements to the right are shifted to the left by 1 position, so there are no empty spaces in the sequence. So after you make a move, the sequence's length decreases by 1. The indices of the elements after the move are recalculated.

E. g. let the sequence be a=[3, 2, 2, 1, 5]. Let's select the element a_3=2 in a move. Then after the move the sequence will be equal to a=[3, 2, 1, 5], so the 3-rd element of the new sequence will be a_3=1 and the 4-th element will be a_4=5.

You are given a sequence a_1, a_2, …, a_n and a number k. You need to find the minimum number of moves you have to make so that in the resulting sequence there will be at least k elements that are equal to their indices, i. e. the resulting sequence b_1, b_2, …, b_m will contain at least k indices i such that b_i = i.

Input

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

Each test case consists of two consecutive lines. The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2000). The second line contains a sequence of integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n). The numbers in the sequence are not necessarily different.

It is guaranteed that the sum of n over all test cases doesn't exceed 2000.

Output

For each test case output in a single line:

  * -1 if there's no desired move sequence; 
  * otherwise, the integer x (0 ≤ x ≤ n) — the minimum number of the moves to be made so that the resulting sequence will contain at least k elements that are equal to their indices. 

Example

Input


4
7 6
1 1 2 3 4 5 6
5 2
5 1 3 2 3
5 2
5 5 5 5 4
8 4
1 2 3 3 2 2 5 5


Output


1
2
-1
2

Note

In the first test case the sequence doesn't satisfy the desired condition, but it can be provided by deleting the first element, hence the sequence will be [1, 2, 3, 4, 5, 6] and 6 elements will be equal to their indices.

In the second test case there are two ways to get the desired result in 2 moves: the first one is to delete the 1-st and the 3-rd elements so that the sequence will be [1, 2, 3] and have 3 elements equal to their indices; the second way is to delete the 2-nd and the 3-rd elements to get the sequence [5, 2, 3] with 2 desired elements.
// #define ONLINE_JUDGE
//                 _
//                (_)
// _ __ ___   __ _ _  ___  _ __ _ __ ___
//| '_ ` _ \ / _` | |/ _ \| '__| '__/ _ \ 
//| | | | | | (_| | | (_) | |  | | | (_) |
//|_| |_| |_|\__,_| |\___/|_|  |_|  \___/
//               _/ |
//              |__/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef tree<
    ll, //
    null_type,
    greater<ll>, //
    rb_tree_tag,
    tree_order_statistics_node_update>
    ordered_set;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngl(chrono::steady_clock::now().time_since_epoch().count());

#define majorro              \
    cout.precision(20);      \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
#define pb push_back
#define forn(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define fornm(i, m, n) for (ll(i) = (m); (i) < (n); ++(i))
#define rfornm(i, m, n) for (ll(i) = (m); (i) >= (n); --(i))
#define readvec(vector, n)                  \
    {                                       \
        ll temp_vec_val;                    \
        forn(inc, n)                        \
        {                                   \
            cin >> temp_vec_val;            \
            vector.push_back(temp_vec_val); \
        }                                   \
    }
#define printvec(vector, delimeter)                                                     \
    {                                                                                   \
        ll length_of_vector = vector.size();                                            \
        forn(elementvec, length_of_vector) { cout << vector[elementvec] << delimeter; } \
    }
#define all(vector) (vector).begin(), (vector).end()
#define rall(vector) (vector).rbegin(), (vector).rend()
#define endl "\n"
#define sz(something) (ll) something.size()

struct pair_hash
{
    template <class T1, class T2>
    size_t operator()(const pair<T1, T2> &pair) const
    {
        return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
    }
};

const ld EPS = 1e-7;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const ll INF = 1e18;
const ld pi = 2.0 * acos(0.0);
ll n, m, k, p, q, t, sum = 0, cnt = 0;
ll mx = -INF;
ll mn = INF;
bool flag = 0;
vll v;
string s = "", s1, s2;
char c;

void solve()
{
    cin >> t;
    while (t--)
    {
        cin >> n >> k;
        v.clear();
        readvec(v,n);
        vector<vector<vll>> dp(n+1,vector<vll>(n+1,vll(2,0)));
        fornm(i,1,n+1)
        {
            forn(j,i)
            {
                p = i-j==v[i-1];
                q = i-(j-1)==v[i-1];
                dp[i][j][0] = max(dp[i][j][0],dp[i-1][j][0]+p);
                dp[i][j][1] = max(dp[i][j][1],dp[i-1][j][0]);
                if(j)
                {
                    dp[i][j][0] = max(dp[i][j][0],dp[i-1][j-1][1]+q);
                    dp[i][j][1] = max(dp[i][j][1],dp[i-1][j-1][1]);
                }
            }
        }
        flag=0;
        forn(i,n+1)
        {
            if(dp[n][i][0]>=k||dp[n][i][1]>=k)
            {
                flag=1;
                cout << i << endl;
                break;
            }
        }
        if(!flag) cout << -1 << endl;
    }
}

int main()
{
#if defined ACMP
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#elif !defined ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    majorro
    solve();
    return 0;
} //