#include "bits/stdc++.h"
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
 
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
 
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
 
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;

template<class T> using pq = priority_queue<T>;
template<class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
 
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)
#define uid(a, b) uniform_int_distribution<int>(a, b)(rng)
 
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert

template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
 
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}

template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ", "; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? ", " : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifdef DEBUG
#define dbg(x...) cerr << "\e[91m"<<__func__<<":"<<__LINE__<<" [" << #x << "] = ["; _print(x); cerr << "\e[39m" << endl;
#else
#define dbg(x...)
#endif


const int MOD = 1000000007;
const char nl = '\n';
const int MX = 21; 

int N, M, K;
vector<vi> goal;
vector<vi> cur;
vector<vector<vi>> pats;
vector<array<int, 3>> ops;

void execute(vector<vi> &pat) {
    F0R(i, sz(pat)) {
        F0R(j, sz(pat[0])) {
            cur[i][j] = 0;
        }
    }
    //dbg(cur);
}

void moveTo(int x, int y, int i, int j) {
    while (y > j) {
        ops.pb({-2, x+1, y+1});
        swap(cur[x][y], cur[x][y-1]);
        y--;
    }
    while (y < j) {
        ops.pb({-1, x+1, y+1});
        swap(cur[x][y], cur[x][y+1]);
        y++;
    }
    while (x > i) {
        ops.pb({-4, x+1, y+1});
        swap(cur[x][y], cur[x-1][y]);
        x--;
    }
    while (x < i) {
        ops.pb({-3, x+1, y+1});
        swap(cur[x][y], cur[x+1][y]);
        x++;
    }
    assert(x == i); assert(y == j);
}

bool makePat(vector<vi> &pat, bool checkFound) {
    int cnt[64]; F0R(i, 64) cnt[i] = 0;
    F0R(i, N) F0R(j, M) cnt[cur[i][j]]++;
    bool found = false;
    F0R(i, sz(pat)) F0R(j, sz(pat[0])) {
        if (cnt[pat[i][j]]) {
            cnt[pat[i][j]]--;
            found = true;
        } else if (cnt[0]) {
            cnt[0]--;
       } else return false;
    }
    if (checkFound && !found) return false;

    F0R(i, sz(pat)) {
        F0R(j, sz(pat[0])) {
            int x = -1, y = -1;
            F0R(a, N) {
                F0R(b, M) {
                    if (a*M+b >= i*M+j && cur[a][b] == pat[i][j]) {
                        x = a; y = b; goto done;
                    }
                }
            }
            F0R(a, N) {
                F0R(b, M) {
                    if (a*M+b >= i*M+j && cur[a][b] == 0) {
                        x = a; y = b; goto done;
                    }
                }
            }
            done:
            ;
            assert(x != -1);
            moveTo(x, y, i, j);
        }
    }

    execute(pat);
    return true;
}

void solve() {
    cin >> N >> M >> K;
    goal = vector<vi>(N, vi(M));
    cur = vector<vi>(N, vi(M));

    int cs[256];
    F0R(i, 26) {
        cs['a' + i] = 1 + i;
    }
    F0R(i, 26) {
        cs['A' + i] = 27 + i;
    }
    F0R(i, 10) {
        cs['0' + i] = 53 + i;
    }

    F0R(i, N) {
        F0R(j, M) {
            char C; cin >> C;
            goal[i][j] = cs[(int)C];
        }
    }
    F0R(i, N) {
        F0R(j, M) {
            char C; cin >> C;
            cur[i][j] = cs[(int)C];
        }
    }
    F0R(iter, K) {
        int X, Y; cin >> X >> Y;
        vector<vi> curPat(X, vi(Y));
        F0R(i, X) {
            F0R(j, Y) {
                char C; cin >> C;
                curPat[i][j] = cs[(int)C];
            }
        }
        pats.pb(curPat);
    }

    bool ok = true;
    while (ok) {
        ok = false;
        F0R(p, sz(pats)) {
            if (makePat(pats[p], true)) {
                ok = true;
                ops.pb({p+1, 1, 1});
                pi pos[64]; F0R(i, 64) pos[i] = {-1, -1};
                F0R(i, sz(pats[p])) {
                    F0R(j, sz(pats[p][0])) {
                        pos[pats[p][i][j]] = {i, j};
                    }
                }
                bool found = true;
                while (found) {
                    found = false;
                    F0R(i, N) {
                        F0R(j, M) {
                            if (pos[cur[i][j]].f != -1) {
                                pi c = pos[cur[i][j]];
                                found = true;
                                moveTo(i, j, c.f, c.s);
                                execute(pats[p]);
                                ops.pb({p+1, 1, 1});
                            }
                        }
                    }
                }
            }
        }
    }

    if (!makePat(goal, false)) {
        cout << -1 << nl; return;
    }
    reverse(all(ops));
    cout << sz(ops) << nl;
    trav(a, ops) {
        cout << a[0] << " " << a[1] << " " << a[2] << nl;
    }


}
 
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);

    int T = 1;
//    cin >> T;
    while(T--) {
        solve();
    }

	return 0;
}