#pragma GCC optimize("Ofast,unroll-loops")
#include<bits/stdc++.h>
#define rep(i,s,n) for (int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ld = long double;

template<class T>
bool chmin(T &a, T b) {
    if(a <= b) return false;
    a = b;
    return true;
}

template<class T>
bool chmax(T &a, T b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;

template <ll m> struct modint {
    using mint = modint;
    ll a;
    modint(ll x = 0) : a((x % m + m) % m) {}
    static ll mod(){
        return m;
    }
    ll& val(){
        return a;
    }
    mint pow(ll n){
        mint res = 1;
        mint x = a;
        while (n){
            if (n & 1) res *= x;
            x *= x;
            n >>= 1;
        }
        return res;
    }
    mint inv(){
        return pow(m-2);
    }
    mint& operator+=(const mint rhs){
        a += rhs.a;
        if (a >= m) a -= m;
        return *this;
    }
    mint& operator-=(const mint rhs){
        if (a < rhs.a) a += m;
        a -= rhs.a;
        return *this;
    }
    mint& operator*=(const mint rhs){
        a = a * rhs.a % m;
        return *this;
    }
    mint& operator/=(mint rhs){
        *this *= rhs.inv();
        return *this;
    }
    friend mint operator+(const mint& lhs, const mint& rhs){
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs){
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs){
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs){
        return mint(lhs) /= rhs;
    }
    int operator+() const{
        return *this;
    }
    int operator-() const{
        return mint() - *this;
    }
};

using modint1000000007 = modint<1'000'000'007>;
typedef modint1000000007 mint;

vector<vector<mint>> gauss_jordan(vector<vector<mint>> &a){
    int n = a.size();
    int m = a[0].size();
    vector<vector<mint>> b = a;
    int piv = 0;
    rep(j,0,m) rep(i,piv,n){
        if (b[i][j].val() != 0){
            swap(b[i], b[piv]);
            mint ip = mint(1) / b[piv][j];
            rep(l,0,n){
                if (l != piv){
                    mint tmp = ip * b[l][j];
                    rep(k,j,m) b[l][k] -= tmp * b[piv][k];
                }
            }
            rep(k,j,m) b[piv][k] *= ip;
            piv++;
            break;
        }
    }
    return b;
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    random_device seed_gen;
    mt19937 engine(seed_gen());

    int n; cin >> n;
    vector<vector<mint>> a(n, vector<mint>(n));
    vector<vector<mint>> c(n, vector<mint>(n));
    
    // input
    rep(i,0,n){
        rep(j,0,n){
            int x; cin >> x;
            a[i][j] = x;
        }
    }
    
    rep(i,0,n){
        rep(j,0,n){
            int x; cin >> x;
            c[i][j] = x;
        }
    }


    // find tenchi
    auto tenchi = [&](vector<vector<mint>> &a) -> vector<vector<mint>> {
        vector<vector<mint>> ret(n, vector<mint>(n));
        rep(i,0,n){
            rep(j,0,n){
                ret[i][j] = a[j][i];
            }
        }
        return ret;
    };

    // at, ct .. tenchi
    vector<vector<mint>> at = tenchi(a);
    vector<vector<mint>> ct = tenchi(c);
    
    // find wrong line with random
    const int RANDOM_NUM = 3;
    uniform_int_distribution<int> dist(0, 1'000'000'006);

    // matrix * vector 
    auto mult_vec = [&](vector<vector<mint>> &f, const vector<mint> &x) -> vector<mint> {
        vector<mint> ret(n);
        rep(i,0,n){
            rep(j,0,n){
                ret[i] += f[i][j] * x[j];
            }
        }
        return ret;
    };

    auto find_wrong_line = [&](vector<vector<mint>> &a, vector<vector<mint>> &c) -> vector<int> {
        vector<mint> x(n);
        vector<bool> fail(n);
        rep(num,0,RANDOM_NUM){
            rep(i,0,n){
                int z = dist(engine);
                x[i] = z;
            }
            vector<mint> tmp = mult_vec(c, mult_vec(a, x));
            rep(i,0,n){
                if (tmp[i].val() != x[i].val()){
                    fail[i] = true;
                }
            }
        }
        vector<int> ret;
        rep(i,0,n){
            if (fail[i]){
                ret.push_back(i);
            }
        }
        return ret;
    };

    vector<int> wrong_gyou = find_wrong_line(a, c); // <= 12
    vector<int> wrong_retsu = find_wrong_line(at, ct); // <= 12
    
    vector<int> is_wrong_retsu(n, -1);
    int piv = 0;
    for (int i: wrong_retsu){
        is_wrong_retsu[i] = piv;
        piv++;
    }

    // output if no mistake
    if (piv == 0){
        cout << 0 << '\n';
        return 0;
    }

    // NEXT -> make linear houteisiki
    vector<tuple<int,int,int>> ans;
    piv = 0;
    //int alls = (int)wrong_gyou.size() * (int)wrong_retsu.size();
    int hens = (int)wrong_retsu.size();
    for (int i: wrong_gyou){
        vector<vector<mint>> arr(n, vector<mint>(hens + 1));
        rep(j,0,n){
            rep(k,0,n){
                if (is_wrong_retsu[k] == -1){
                    arr[j][hens] -= c[i][k] * a[k][j];
                }else{
                    arr[j][is_wrong_retsu[k]] += a[k][j];
                }
            }
            if (i == j){
                arr[j][hens] += 1;
            }
        }
        vector<vector<mint>> gs = gauss_jordan(arr);
        /*
        rep(j,0,n){
            rep(k,0,hens + 1){
                cout << gs[j][k].val() << ' ';
            }
            cout << endl;
        }
        //*/
        rep(j,0,hens){
            assert (gs[j][j].val() == 1);
        }
        rep(j,hens,n){
            assert (gs[j][hens].val() == 0);
        }
        rep(j,0,hens){
            if (c[i][wrong_retsu[j]].val() != gs[j][hens].val()){
                ans.push_back(make_tuple(i, wrong_retsu[j], gs[j][hens].val()));
            }
            c[i][wrong_retsu[j]] = gs[j][hens];
        }
    }

    int ans_size = ans.size();
    cout << ans_size << '\n';
    rep(i,0,ans_size){
        auto [x, y, z] = ans[i];
        cout << x+1 << ' ' << y+1 << ' ' << z << '\n';
    }
}