#include<bits/stdc++.h>
// #define ONLINE_JUDGE
#define INPUT_DATA_TYPE int
#define OUTPUT_DATA_TYPE int
INPUT_DATA_TYPE read(){register INPUT_DATA_TYPE x=0;register char f=0,c=getchar();while(c<'0'||'9'<c)f=(c=='-'),c=getchar();while('0'<=c&&c<='9')x=(x<<3)+(x<<1)+(c&15),c=getchar();return f?-x:x;}void print(OUTPUT_DATA_TYPE x){if(x<0)x=-x,putchar('-');if(x>9)print(x/10);putchar(x%10^48);return;}

const int UFDS_SIZE=510;
struct UFDS{
	int parents[UFDS_SIZE];

	void build(int n){
		for(register int i=1;i<=n;++i)
			parents[i]=i;
		return;
	}

	int find(int x){
		return x==parents[x]?x:(parents[x]=find(parents[x]));
	}

	int find_b(int x){
		while(parents[x]!=x)
			x=parents[x];
		return x;
	}

	void merge(int i,int j){
		parents[find(i)]=find(j);
		return;
	}

	void clear(){
		for(int i=1;i<UFDS_SIZE;i++)
			parents[i]=i;
		return;
	}
}UB,UC;

#define NOOOOOO \
{puts("NO");\
return 0;}

struct EDGE{
    int u,v,w;
    bool operator < (const EDGE o) const{
        return w>o.w;
    }
};

std::vector<EDGE> edges_b,edges_c,outE;

int B[510][510],C[510][510],Bnew[510][510],Cnew[510][510];

int main(){
	#ifndef ONLINE_JUDGE
	freopen("name.in", "r", stdin);
	freopen("name.out", "w", stdout);
	#endif

    memset(Bnew,~0x3f,sizeof(Bnew));
    memset(Cnew,~0x3f,sizeof(Cnew));

    register int i,j,k,u,v,W;

    int n=read();
    W=read();

    for(u=0;u<n;++u)
        for(v=0;v<u;++v)
            B[u][v]=B[v][u]=read();
    for(u=0;u<n;++u)
        for(v=0;v<u;++v)
            C[u][v]=C[v][u]=read();

    for(u=0;u<n;++u)
        for(v=0;v<u;++v)
            for(k=0;k<n;++k)
                if(k!=u&&k!=v&&(B[u][v]<std::min(B[u][k],B[k][v])||C[u][v]<std::min(C[u][k],C[k][v]))) NOOOOOO

    for(u=0;u<n;++u)
        for(v=0;v<u;++v)
            if(B[u][v]+C[u][v]>=W){
                edges_b.push_back((EDGE){u,v,B[u][v]});
                edges_c.push_back((EDGE){u,v,C[u][v]});
            }

    std::sort(edges_b.begin(),edges_b.end());
    std::sort(edges_c.begin(),edges_c.end());

    UB.build(n),UC.build(n);

    for(auto edge:edges_b)
        if(UB.find(edge.u)!=UB.find(edge.v))
            Bnew[edge.u][edge.v]=Bnew[edge.v][edge.u]=edge.w,
            outE.push_back((EDGE){edge.u,edge.v,W-edge.w}),
            UB.merge(edge.u,edge.v);

    for(auto edge:edges_c)
        if(UC.find(edge.u)!=UC.find(edge.v))
            Cnew[edge.u][edge.v]=Cnew[edge.v][edge.u]=edge.w,
            outE.push_back(edge),
            UC.merge(edge.u,edge.v);

    for(k=0;k<n;++k)
        for(u=0;u<n;++u)
            for(v=0;v<u;++v)
                if(k!=u&&k!=v)
                    Bnew[u][v]=Bnew[v][u]=std::max(Bnew[u][v],std::min(Bnew[u][k],Bnew[k][v])),
                    Cnew[u][v]=Cnew[v][u]=std::max(Cnew[u][v],std::min(Cnew[u][k],Cnew[k][v]));

    for(u=0;u<n;++u)
        for(v=0;v<u;++v)
            if(B[u][v]!=Bnew[u][v]||C[u][v]!=Cnew[u][v]||Bnew[u][v]<0||Cnew[u][v]<0) NOOOOOO

    print(outE.size()),putchar('\n');
    for(auto edge:outE) print(edge.u),putchar(' '),print(edge.v),putchar(' '),print(edge.w),putchar('\n');

	#ifndef ONLINE_JUDGE
	fclose(stdin);
	fclose(stdout);
	#endif
    return 0;
}