John's barn has a fence consisting of N consecutive parts numbered from left to right starting from 1 to N. Each part is initially painted in one of two colors: red or green, whose information is provided you by a stringC. The color of i-th part C_i will be equal to 'R' if the color of the part is red and 'G' if it is green.

John decided to paint the whole fence in green color. To make the mundane process of painting more entertaining he decided to do it using the following process.
Every minute (until the whole fence is painted green) he will do the following steps:

• Choose any part of the fence that is painted red. Let's denote the index of this part as X.
• For each part with indices X, X+1, ..., min(N, X + K - 1), flip the color of the corresponding part from red to green and from green to red by repainting.

John is wondering how fast he can repaint the fence. Please help him in finding the minimum number of minutes required in repainting.

Input

The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.

The first line of each test case contains the two integers N and K.

The next line contains the string C.

Output

For each test case, output a single line containing the answer to the corresponding test case.

Constraints

• 1 ≤ T ≤ 10
• 1 ≤ N, K ≤ 10⁵
• C will consist only of uppercase English characters 'R' and 'G'.

Example

Input:
1
7 3
RGGRGRG

Output:
4

Explanation

Example case 1. One optimal solution (with 4 steps) looks like this:

• Choose the 1-st character (1-based index) and get "GRRRGRG".
• Choose the 2-st character (1-based index) and get "GGGGGRG".
• Choose the 6-th character (1-based index) and get "GGGGGGR".
• Choose the 7-th charatcer (1-based index) and get "GGGGGGG".
• Now repainting is done :) It took total 4 steps. Hence answer is 4.

This is a very cool and nice implementation of range update.  This can be achieved in o(n) time.

We need to observe few things,

(1)  We can go greedily by chaging whenever we encounter a red colour and this is definitely the minimum operations.

(2)  If we change red colour even number of times then it needs to be changed again and if we change green colour odd number of times, then its status is red now ,so it needs to be flipped.

We can see if we represent green as 0 and red as 1  then flipping can simply be represented as adding 1(mod 2) in this we we keep a status whenever we meet the next flag. It is noticeable that if we want to add 1 to the range L to R it can be also done by adding 1 to L and adding -1 to R+1. Using all this we write the code.

#include<bits/stdc++.h>

using namespace std;

int dp[1000100];

int main()

{

int t;

cin>>t;

string str;

while(t--)

{

int n,k;

cin>>n>>k;

cin>>str;

//int l=str.length();

memset(dp,0,sizeof(dp));

int status=0;

int ans=0;

for(int i=0;i<n;i++)

{

  status+=dp[i];

  if((str[i]=='R' && status%2==0) || (str[i]=='G' && status%2==1))

  {

 

  ans++;

  dp[i+1]+=1;

  dp[i+k]+=-1;

  }

}

cout<<ans<<endl;

}

return 0;

}