#include <iostream>

#include <cstdio>

#include <cmath>

#include <string>

#include <cstring>

#include <algorithm>

#include <limits>

#include <vector>

#include <stack>

#include <queue>

#include <set>

#include <map>

#define lowbit(x) ( x&(-x) )

#define pi 3.141592653589793

#define e 2.718281828459045

#define INF 0x3f3f3f3f

#define HalF (l + r)>>1

#define lsn rt<<1

#define rsn rt<<1|1

#define Lson lsn, l, mid

#define Rson rsn, mid+1, r

#define QL Lson, ql, qr

#define QR Rson, ql, qr

#define myself rt, l, r

using namespace std;

typedef unsigned long long ull;

typedef long long ll;

const int maxN = , maxE = 3e4 + , st = ;

int N, D, M, all, head[], cur[], cnt, ed;

char liz[maxN][maxN], jump[maxN][maxN];

struct Eddge

{

    int nex, to, flow;

    Eddge(int a=-, int b=, int c=):nex(a), to(b), flow(c) {}

}edge[maxE];

inline void addEddge(int u, int v, int w)

{

    edge[cnt] = Eddge(head[u], v, w);

    head[u] = cnt++;

}

inline void _add(int u, int v, int w) { addEddge(u, v, w); addEddge(v, u, ); }

inline int _id(int x, int y) { return (x - ) * M + y; }

inline bool can_out(int x, int y) { return x <= D || y <= D || (N - x < D) || (M - y < D); }

bool In_map(int x, int y) { return x >=  && y >=  && x <= N && y<= M; }

int deep[];

queue<int> Q;

inline bool bfs()

{

    for(int i=; i<=ed; i++) deep[i] = ;

    while(!Q.empty()) Q.pop();

    Q.push(st); deep[st] = ;

    while(!Q.empty())

    {

        int u = Q.front(); Q.pop();

        for(int i=head[u], v, f; ~i; i=edge[i].nex)

        {

            v = edge[i].to; f = edge[i].flow;

            if(f && !deep[v])

            {

                deep[v] = deep[u] + ;

                Q.push(v);

            }

        }

    }

    return deep[ed];

}

inline int dfs(int u, int dist)

{

    if(u == ed) return dist;

    for(int &i=cur[u], v, f; ~i; i=edge[i].nex)

    {

        v = edge[i].to; f = edge[i].flow;

        if(f && deep[v] == deep[u] + )

        {

            int di = dfs(v, min(dist, f));

            if(di)

            {

                edge[i].flow -= di;

                edge[i^].flow += di;

                return di;

            }

        }

    }

    return ;

}

inline int Dinic()

{

    int ans = , tmp;

    while(bfs())

    {

        for(int i=; i<=ed; i++) cur[i] = head[i];

        while((tmp = dfs(st, INF))) ans += tmp;

    }

    return ans;

}

inline void init()

{

    all =cnt = ;

    memset(head, -, sizeof(head));

}

int main()

{

    int T; scanf("%d", &T);

    for(int Cas=; Cas<=T; Cas++)

    {

        scanf("%d%d", &N, &D);

        init();

        for(int i=; i<=N; i++) scanf("%s", jump[i] + );

        M = (int)strlen(jump[] + );

        ed =  * N * M + ;

        for(int i=; i<=N; i++)

        {

            scanf("%s", liz[i] + );

            for(int j=; j<=M; j++)

            {

                if(liz[i][j] == 'L')

                {

                    all++;

                    _add(st, _id(i, j), );

                }

            }

        }

        for(int i=, u, v; i<=N; i++)

        {

            for(int j=; j<=M; j++)

            {

                u = _id(i, j);

                if(jump[i][j] > '')

                {

                    _add(u, u + N * M, jump[i][j] - '');

                    if(can_out(i, j))

                    {

                        _add(u + N * M, ed, jump[i][j] - '');

                        continue;

                    }

                    for(int x=; x<=D; x++)

                    {

                        for(int y=D-x; y>=; y--)

                        {

                            if(!x && !y) continue;

                            if(In_map(i + x, j + y))

                            {

                                v = _id(i + x, j + y);

                                _add(u + N * M, v, jump[i][j] - '');

                            }

                            if(In_map(i - x, j + y))

                            {

                                v = _id(i - x, j + y);

                                _add(u + N * M, v, jump[i][j] - '');

                            }

                            if(In_map(i + x, j - y))

                            {

                                v = _id(i + x, j - y);

                                _add(u + N * M, v, jump[i][j] - '');

                            }

                            if(In_map(i - x, j - y))

                            {

                                v = _id(i - x, j - y);

                                _add(u + N * M, v, jump[i][j] - '');

                            }

                        }

                    }

                }

            }

        }

        printf("Case #%d: ", Cas);

        int ans = all - Dinic();

        if(ans == ) printf("no lizard was left behind.\n");

        else if(ans == ) printf("1 lizard was left behind.\n");

        else printf("%d lizards were left behind.\n", ans);

    }

    return ;

}