Problem: You are given a string s consisting of n characters. These characters are among the first k lowercase letters of the Latin alphabet. You have to perform n operations with the string.

During the i-th operation, you take the character that initially occupied the i-th position, and perform one of the following actions with it:

  * swap it with the previous character in the string (if it exists). This operation is represented as L; 
  * swap it with the next character in the string (if it exists). This operation is represented as R; 
  * cyclically change it to the previous character in the alphabet (b becomes a, c becomes b, and so on; a becomes the k-th letter of the Latin alphabet). This operation is represented as D; 
  * cyclically change it to the next character in the alphabet (a becomes b, b becomes c, and so on; the k-th letter of the Latin alphabet becomes a). This operation is represented as U; 
  * do nothing. This operation is represented as 0. 



For example, suppose the initial string is test, k = 20, and the sequence of operations is URLD. Then the string is transformed as follows:

  1. the first operation is U, so we change the underlined letter in test to the next one in the first 20 Latin letters, which is a. The string is now aest; 
  2. the second operation is R, so we swap the underlined letter with the next one in the string aest. The string is now aset; 
  3. the third operation is L, so we swap the underlined letter with the previous one in the string aset (note that this is now the 2-nd character of the string, but it was initially the 3-rd one, so the 3-rd operation is performed to it). The resulting string is saet; 
  4. the fourth operation is D, so we change the underlined letter in saet to the previous one in the first 20 Latin letters, which is s. The string is now saes. 



The result of performing the sequence of operations is saes.

Given the string s and the value of k, find the lexicographically smallest string that can be obtained after applying a sequence of operations to s.

Input

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

Each test case consists of two lines. The first line contains two integers n and k (1 ≤ n ≤ 500; 2 ≤ k ≤ 26). 

The second line contains a string s consisting of n characters. Each character is one of the k first letters of the Latin alphabet (in lower case).

Output

For each test case, print one line containing the lexicographically smallest string that can be obtained from s using one sequence of operations.

Example

Input


6
4 2
bbab
7 5
cceddda
6 5
ecdaed
7 4
dcdbdaa
8 3
ccabbaca
5 7
eabba


Output


aaaa
baccacd
aabdac
aabacad
aaaaaaaa
abadb

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

const int MX = 505;
const int MC = 26;

typedef pair<int, int> pii;

int T, N, K;
int num[MX], rlt[MX];

struct data {

	pii prv, cur, nxt, nxtt;
	data(pii a = pii(0, 0), pii b = pii(0, 0), pii c = pii(0, 0), pii d = pii(0, 0)) { prv = a, cur = b, nxt = c, nxtt = d; }

	inline void R_cur() {
		swap(cur, nxt);
	}
	inline void L_cur() {
		if(~prv.first) swap(cur, prv);
	}
	inline void D_cur() {
		cur.second += K - 1;
		cur.second %= K;
	}
	inline void U_cur() {
		cur.second ++;
		cur.second %= K;
	}
	inline void R_nxt() {
		if(nxt.first < N - 1) swap(nxt, nxtt);
	}
	inline void L_nxt() {
		swap(nxt, cur);
	}
	inline void D_nxt() {
		nxt.second += K - 1;
		nxt.second %= K;
	}
	inline void U_nxt() {
		nxt.second ++;
		nxt.second %= K;
	}
	inline void skin() {
		prv = cur, cur = nxt, nxt = nxtt;
		int ps = max(nxt.first, cur.first) + 1;
		if(ps < N) nxtt = pii(ps, num[ps]);
		if(prv.first < ps) prv.first = ps - 2;
	}
	void out() {
		cerr << '(' << prv.first << ' ' << prv.second << ' ' << cur.first << ' ' << cur.second << ' ' << nxt.first << ' ' << nxt.second << ' ' << nxtt.first << ' ' << nxtt.second << ")\n";
	}
};

bool operator < (data A, data B) {
	if(A.prv != B.prv) return A.prv < B.prv;
	if(A.cur != B.cur) return A.cur < B.cur;
	if(A.nxt != B.nxt) return A.nxt < B.nxt;
	return A.nxtt < B.nxtt;
}

bool operator == (data A, data B) {
	return A.prv == B.prv && A.cur == B.cur && A.nxt == B.nxt && A.nxtt == B.nxtt;
}

char str[MX];

inline int toint(char c) {
	return c - 'a';
}

inline char tochar(int a) {
	return 'a' + a;
}

vector<data> V;

void build() {
	V.clear();
	data d(pii(-1, 0), pii(0, num[0]), pii(1, num[1]), pii(2, num[2])), d1;
	d1 = d, d1.R_cur(), V.push_back(d1);
	d1 = d, d1.U_cur(), V.push_back(d1);
	d1 = d, d1.L_cur(), V.push_back(d1);
	d1 = d, d1.D_cur(), V.push_back(d1);
	d1 = d, V.push_back(d1);
	sort(V.begin(), V.end());
	V.erase(unique(V.begin(), V.end()), V.end());
	vector<data> v;
	v.clear();
	for(data u : V) {
		if(u.nxt.first == 1) {
			d1 = u, d1.R_nxt(), v.push_back(d1);
			d1 = u, d1.U_nxt(), v.push_back(d1);
			d1 = u, d1.L_nxt(), v.push_back(d1);
			d1 = u, d1.D_nxt(), v.push_back(d1);
			d1 = u, v.push_back(d1);
		} else if(u.cur.first == 1) {
			d1 = u, d1.R_cur(), v.push_back(d1);
			d1 = u, d1.U_cur(), v.push_back(d1);
			d1 = u, d1.L_cur(), v.push_back(d1);
			d1 = u, d1.D_cur(), v.push_back(d1);
			d1 = u, v.push_back(d1);
		} else assert(0);
	}
	V.clear();
	for(data u : v) u.skin(), V.push_back(u);
	sort(V.begin(), V.end());
	V.erase(unique(V.begin(), V.end()), V.end());
}

void extend(int i) {
	data d1;
	vector<data> v;
	v.clear();
	int c = MC, cc = MC;
	for(data u : V) c = min(u.prv.second, c);
	for(data u : V) {
		if(u.cur.first == i) {
			d1 = u, d1.R_cur();
			if(d1.prv.second < c) v.clear();
			if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
			d1 = u, d1.L_cur();
			if(d1.prv.second < c) v.clear();
			if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
			d1 = u, d1.U_cur();
			if(d1.prv.second < c) v.clear();
			if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
			d1 = u, d1.D_cur();
			if(d1.prv.second < c) v.clear();
			if(d1.prv.second <= c) v.push_back(d1), c = min(d1.prv.second, c);
			d1 = u, v.push_back(d1);
		} else if(u.nxt.first == i) {
			if(u.prv.second > c) continue;
			d1 = u, d1.R_nxt(), v.push_back(d1);
			d1 = u, d1.U_nxt(), v.push_back(d1);
			d1 = u, d1.L_nxt(), v.push_back(d1);
			d1 = u, d1.D_nxt(), v.push_back(d1);
			d1 = u, v.push_back(d1);
		};
	}
	for(data u : v) {
		if(u.prv.second == c) cc = min(u.cur.second, cc);
	}
	rlt[i - 2] = c;
	V.clear();
	for(data u : v) {
		if(u.prv.second != c) continue;
		if(u.cur.second != cc && u.nxt.first != i + 1 && i < N) continue;
		u.skin(), V.push_back(u);
	}
	assert(!V.empty());
	sort(V.begin(), V.end());
	V.erase(unique(V.begin(), V.end()), V.end());
}

void final() {
	vector<pii> v;
	v.clear();
	for(data u : V) {
		v.push_back(pii(u.prv.second, u.cur.second));
	}
	sort(v.begin(), v.end());
	rlt[N - 2] = v[0].first, rlt[N - 1] = v[0].second;
}

int main() {
#ifndef ONLINE_JUDGE
	freopen("I", "r", stdin);
	freopen("O", "w", stdout);
#endif

	int i, j;
	for(scanf("%d", &T); T --; ) {
		scanf("%d%d", &N, &K);
		scanf("%s", str);
		if(N == 1) {
			if(toint(str[0]) == K - 1) str[0] = 'a';
			else if(str[0] > 'a') str[0] --;
			printf("%s\n", str);
			continue;
		}
		for(i = 0; i < N; i ++) num[i] = toint(str[i]);
		build();
		for(i = 2; i < N; i ++) extend(i);
		final();
		for(i = 0; i < N; i ++) putchar(tochar(rlt[i]));
		puts("");
	}

	return 0;
}