#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;
struct DSU {
    std::vector<int> f, siz;
    
    DSU() {}
    DSU(int n) {
        init(n);
    }
    
    void init(int n) {
        f.resize(n);
        std::iota(f.begin(), f.end(), 0);
        siz.assign(n, 1);
    }
    
    int find(int x) {
        while (x != f[x]) {
            x = f[x] = f[f[x]];
        }
        return x;
    }
    
    bool same(int x, int y) {
        return find(x) == find(y);
    }
    
    bool merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) {
            return false;
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }
    
    int size(int x) {
        return siz[find(x)];
    }
};
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N, W;
    std::cin >> N >> W;
    
    std::vector C(N, std::vector<int>(N));
    std::vector B(N, std::vector<int>(N));
    
    auto get = [&](auto &e) {
        DSU dsu(N);
        std::sort(e.begin(), e.end(), std::greater());
        std::vector f(N, std::vector<int>(N, -1));
        for (int i = 0; i < N; i++) {
            f[i][i] = 0;
        }
        std::vector<std::array<int, 3>> ne;
        std::vector<std::vector<int>> set(N);
        for (int i = 0; i < N; i++) {
            set[i] = {i};
        }
        for (auto [w, u, v] : e) {
            if (!dsu.same(u, v)) {
                ne.push_back({w, u, v});
                u = dsu.find(u);
                v = dsu.find(v);
                dsu.merge(u, v);
                for (auto x : set[u]) {
                    for (auto y : set[v]) {
                        f[x][y] = f[y][x] = w;
                    }
                }
                set[u].insert(set[u].end(), set[v].begin(), set[v].end());
                set[v] = {};
            }
        }
        e = std::move(ne);
        return f;
    };
    
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < i; j++) {
            std::cin >> C[i][j];
            C[j][i] = C[i][j];
        }
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < i; j++) {
            std::cin >> B[i][j];
            B[j][i] = B[i][j];
        }
    }
    
    std::vector<std::array<int, 3>> eC, eB;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < i; j++) {
            if (C[i][j] + B[i][j] >= W) {
                eC.push_back({C[i][j], i, j});
                eB.push_back({B[i][j], i, j});
            }
        }
    }
    
    if (get(eC) != C || get(eB) != B) {
        std::cout << "NO\n";
        return 0;
    }
    
    std::cout << eC.size() + eB.size() << "\n";
    for (auto [w, u, v] : eC) {
        std::cout << u << " " << v << " " << W - w << "\n";
    }
    for (auto [w, u, v] : eB) {
        std::cout << u << " " << v << " " << w << "\n";
    }
    
    return 0;
}