#include <cstdio>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <cctype>
#include <set>

namespace uvu
{
#define LOCAL ____________DONT_DEFINE_ME____________
#define ll long long
#define inf 0x3f3f3f3f
// #define int long long
// #define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 20);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
	return getchar();
#else
	if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
	return iS == iT ? EOF : *iS++;
#endif
#define getchar ERR
}

void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher(){ Flush(); } }iamflusher;

void putc(char c)
{
#ifdef LOCAL
	putchar(c);
#else
	*oS++ = c;
	if(oS == oT) Flush();
#endif
#define putchar ERR
}

template <typename T = int> T read()
{
	T x = 0, f = 1; char c = getc();
	for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
	for(;  isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
	return x * f;
}

template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
	top = 0;
	if(x < 0) putc('-'), x = -x;
	if(!x) sta[top = 1] = 0;
	for(; x; x /= 10) sta[++top] = x % 10;
	for(; top; ) putc(sta[top--] ^ 48);
	if(c) putc(c);
}

int readstr(char *s, int base)
{
	int idx = base - 1; char c = getc();
	for(; !(isdigit(c) || isalpha(c) || c == '#' || c == '.'); c = getc());
	for(;   isdigit(c) || isalpha(c) || c == '#' || c == '.' ; c = getc()) s[++idx] = c;
	return idx - base + 1;
}

void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args>
void printf(const char *s, T x, Args ... rest)
{
	for(; *s; s++)
	{
		if(*s != '%') { putc(*s); continue; }
		s++; if(*s == 'd') print(x, 0);
		else if(*s == 'c') putc(x);
		printf(s + 1, rest ...);
		return;
	}
}

template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
// #define mod 998244353
// #define mod 1000000007
// int sm(int x) { return x >= mod ? x - mod : x; }
// void plus_(int &x, int y) { x = sm(x + y); }
// void mul_(int &x, int y) { x = 1ll * x * y % mod; }
// int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }

#define N 1000010
#define M 1010
const int base1 = 121;
const int base2 = 131;
const int mod1 = 998244853;
const int mod2 = 1000000009;
int base1pow[N], base2pow[N];
struct hs
{
	int v1, v2;
	bool operator == (hs B) { return v1 == B.v1 && v2 == B.v2; }
	hs up(int x) { return (hs){(int)(1ll * v1 * base1pow[x] % mod1), (int)(1ll * v2 * base2pow[x] % mod2)}; }
	hs operator + (int x) { return (hs){(v1 + x) % mod1, (v2 + x) % mod2}; }
	hs operator - (hs B) { return (hs){(v1 + mod1 - B.v1) % mod1, (v2 + mod2 - B.v2) % mod2}; }
}pres[N], pret[N];
hs hashs(int l, int r) { return pres[r] - pres[l - 1].up(r - l + 1); }
hs hasht(int l, int r) { return pret[r] - pret[l - 1].up(r - l + 1); }

int n, m, K;
char s[N], t[N];
int lcp(int x, int y) 
{
	int res = 0;
	for(int l = 1, r = std::min(n - x + 1, m - y + 1), mid; l <= r; )
	{
		mid = (l + r) >> 1;
		if(hashs(x, x + mid - 1) == hasht(y, y + mid - 1)) res = mid, l = mid + 1; 
		else r = mid - 1;
	}
	return res;
}
const int DT = 1000;
int dp[M][M << 1], lst[M][M << 1], val[M][M << 1];

void solve()
{
	// memset(h, idx = -1, sizeof(h));
	n = read(), m = read(), K = read();
	readstr(s, 1); readstr(t, 1);
	for(int i = 1; i <= n; i++) pres[i] = pres[i - 1].up(1) + (s[i] - 'a' + 1);
	for(int i = 1; i <= m; i++) pret[i] = pret[i - 1].up(1) + (t[i] - 'a' + 1);
	// memset(dp, -1, sizeof(dp));
	for(int i = 0; i <= K; i++) for(int j = -K; j <= K; j++) dp[i][j + DT] = -1;
	dp[0][DT] = 0;
	for(int i = 0; i <= K; i++)
	{
		for(int j = -K; j <= K; j++) if(~dp[i][j + DT]) // x - y = j
		{
			dp[i][j + DT] += lcp(dp[i][j + DT] + 1, dp[i][j + DT] + 1 - j);
			if(i == K) continue;
			auto upd = [&](int y, int z, int o) -> void { if(y < -K || y > K) return; if(z >= dp[i + 1][y + DT]) dp[i + 1][y + DT] = z, lst[i + 1][y + DT] = j, val[i + 1][y + DT] = o; };
			if(dp[i][j + DT] != n) upd(j + 1, dp[i][j + DT] + 1, 0);
			if(dp[i][j + DT] - j != m) upd(j - 1, dp[i][j + DT], 1);
			if(dp[i][j + DT] != n && dp[i][j + DT] - j != m) upd(j, dp[i][j + DT] + 1, 2);
		}
	}
	if(abs(n - m) > K) { printf("NO\n"); return; }
	// for(int _ = 0; _ <= K; _++) printf("dp[%d][%d] = %d\n", _, n - m, dp[_][n - m + DT]);
	for(int _ = 0; _ <= K; _++)	if(dp[_][n - m + DT] == n)
	{
		printf("YES\n%d\n", _);
		int i = _, j = n - m;
		while(i)
		{
			int k = lst[i][j + DT];
			// printf("dp[%d][%d] = %d, dp[%d][%d] = %d\n", i, j, dp[i][j + DT], i - 1, k, dp[i - 1][k + DT]);
			if(val[i][j + DT] == 0) printf("DELETE %d\n", dp[i - 1][k + DT] + 1);
			if(val[i][j + DT] == 1) printf("INSERT %d %c\n", dp[i - 1][k + DT] + 1, t[dp[i - 1][k + DT] - k + 1]);
			if(val[i][j + DT] == 2) printf("REPLACE %d %c\n", dp[i - 1][k + DT] + 1, t[dp[i - 1][k + DT] - k + 1]);
			i--, j = k;
		}
		return;
	}
	printf("NO\n");
}

void init()
{
	base1pow[0] = base2pow[0] = 1;
	for(int i = 1; i < N; i++)
	{
		base1pow[i] = 1ll * base1pow[i - 1] * base1 % mod1;
		base2pow[i] = 1ll * base2pow[i - 1] * base2 % mod2;
	}
}

char _ED_;

void mian()
{
	debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
	init();
	for(int T = read(); T; solve(), T--);
}

#ifdef int
	#undef int
#endif
}

int main()
{
	uvu::mian(); return 0;
}