//
// Stvoreno ENERGom o 11.04.24. 12:41:50
//

#include <bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define F first
#define fir first
#define S second
#define sec second
#define mp make_pair
#define MP make_pair
#define pb push_back
#define PB push_back

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

#ifdef Energy
#define DEBUG for (int _____DEBUG=1;_____DEBUG;_____DEBUG=0)

template<class ...Ts>
auto &PRNT(Ts ...ts) { return ((cerr << ts << " "), ...); }

#define LOG(...) PRNT(#__VA_ARGS__" ::",__VA_ARGS__)<<endl
#else
#define DEBUG while (0)
#define LOG(...)
#endif

const int mod1 = 998244353;
const int mod2 = 754974721;

template<int mod>
struct NTT
{
    static constexpr int max_lev=__builtin_ctz(mod-1);

    int prod[2][max_lev-1];

    int mul(int a,int b) const {
        return 1ll*a*b%mod;
    }

    void inc(int& a,int b) const {
        a+=b;
        if (a>=mod){
            a-=mod;
        }
    }
    void dec(int& a,int b) const {
        a-=b;
        if (a<0){
            a+=mod;
        }
    }

    int power(int a,int n) const {
        int res=1;
        while (n){
            if (n&1){
                res=mul(res,a);
            }
            n/=2;
            a=mul(a,a);
        }
        return res;
    }
    int inv(int a) const {
        return power(a,mod-2);
    }

    NTT()
    {
        int root=(mod==mod1?31:-1);
        if (mod == mod2) {
            root = 362;
        }
        assert(root!=-1);

        int rroot=inv(root);

        vector<vector<int>> r(2,vector<int>(max_lev-1));
        r[0][max_lev-2]=root;
        r[1][max_lev-2]=rroot;
        for (int tp=0;tp<2;tp++){
            for (int i=max_lev-3;i>=0;i--){
                r[tp][i]=mul(r[tp][i+1],r[tp][i+1]);
            }
        }
        for (int tp=0;tp<2;tp++){
            int cur=1;
            for (int i=0;i<max_lev-1;i++){
                prod[tp][i]=mul(cur,r[tp][i]);
                cur=mul(cur,r[tp^1][i]);
            }
        }
    }

    template<bool inverse>
    void fft(int* a,int lg) const {
        const int n=(1ll<<lg);
        for (int it=0;it<lg;it++){
            const int h=inverse?lg-1-it:it;
            const int d=(1ll<<(lg-h-1));
            int coef=1;
            for (int s=0;s<(1ll<<h);s++){
                for (int i=(s<<(lg-h));i<(s<<(lg-h))+d;i++){
                    if (!inverse){
                        int y=mul(a[i+d],coef);
                        a[i+d]=a[i];
                        inc(a[i],y);
                        dec(a[i+d],y);
                    }
                    else{
                        int y=mul(a[i]+mod-a[i+d],coef);
                        inc(a[i],a[i+d]);
                        a[i+d]=y;
                    }
                }
                coef=mul(coef,prod[inverse][__builtin_ctz(~s)]);
            }
        }
        if (inverse){
            const int rn=inv(n);
            for (int i=0;i<n;i++){
                a[i]=mul(a[i],rn);
            }
        }
    }

    vector<int> product(vector<int> a,vector<int> b) const {
        if (a.empty() || b.empty()){
            return {};
        }
        const int sz=len(b);
        const int lg=((sz==1)?0:(32-__builtin_clz(sz-1))), n=(1ll<<lg);
        a.resize(n);
        b.resize(n);
        fft<false>(a.data(),lg);
        fft<false>(b.data(),lg);
        for (int i=0;i<n;i++){
            a[i]=mul(a[i],b[i]);
        }
        fft<true>(a.data(),lg);
        a.resize(sz);
        return a;
    }
};

const int max_x = 111;

const int max_n = 1011, inf = 1000111222;

int need;
int n[2], m[2], a[2][max_n][max_n];
int f[2][max_n][max_n];
int x[max_x], rx[max_x];
mt19937 gen;

template<int mod>
void proc(int f[max_n][max_n]) {
    NTT<mod> ntt;
//    for (int it = 0; it < 2; ++it) {
//        for (int i = 0; i < n[it]; ++i) {
//            ntt.fft<false>(a[it][i], 11);
//        }
//    }
    for (int i = 0; i < max_x; ++i) {
        x[i] = gen() % (mod - 47) + 47;
        rx[i] = ntt.inv(x[i]);
    }

    vector<int> A[2];
    const int M = m[0] + m[1];
    for (int it = 0; it < 2; ++it) {
        A[it].resize(n[it] * M);
        for (int i = 0; i < n[it]; ++i) {
            for (int j = 0; j < m[it]; ++j) {
                int val = 0;
                if (it == 0) {
                    if (a[it][i][j]) {
                        val = x[a[it][i][j]];
                    }
                } else {
                    val = rx[a[it][i][j]];
                }
                A[it][i * M + j] = val;
            }
        }
    }
    auto C = ntt.product(A[0], A[1]);
    for (int i = 0; i + n[0] <= n[1]; ++i) {
        for (int j = 0; j + m[0] <= m[1]; ++j) {
            if (C[(i + n[0] - 1) * M + j + m[0] - 1] == need) {
                f[i][j] = 1;
            }
        }
    }
}

int main() {
//    freopen("input.txt","r",stdin);
//    freopen("output.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    for (int it = 0; it < 2; ++it) {
        cin >> n[it] >> m[it];
        for (int i = 0; i < n[it]; ++i) {
            for (int j = 0; j < m[it]; ++j) {
                cin >> a[it][i][j];
                need += (it == 0 && a[it][i][j] != 0);
            }
        }
        if (it == 0) {
            for (int i = 0; i < n[it]; ++i) {
                reverse(a[it][i], a[it][i] + m[it]);
            }
            for (int j = 0; j < m[it]; ++j) {
                for (int i = 0; i < n[it] - 1 - i; ++i) {
                    swap(a[it][i][j], a[it][n[it] - 1 - i][j]);
                }
            }
        }
    }
    proc<mod1>(f[0]);
    proc<mod2>(f[1]);
    vector<pair<int, int>> ans;
    for (int i = 0; i + n[0] <= n[1]; ++i) {
        for (int j = 0; j + m[0] <= m[1]; ++j) {
            if (f[0][i][j] && f[1][i][j]) {
                ans.push_back({i, j});
            }
        }
    }
    cout << ans.size() << "\n";
    for (auto [x, y] : ans) {
        cout << x + 1 << " " << y + 1 << "\n";
    }
    exit(0);
}