#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using pi = pair<int, int>;
#define mp make_pair
#define f first
#define s second

#define tcT template<class T
tcT> using V = vector<T>;
using vi = V<int>;
using vpi = V<pi>;
using vb = V<bool>;

#define sz(x) int((x).size())
#define all(x) begin(x), end(x)
#define pb push_back
#define rsz resize
#define bk back()

#define each(a, x) for(auto& a: x)
#define FOR(i,a,b) for(int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)

// const int MOD = 1e9+7;
tcT> bool ckmin(T& a, const T& b){
	return b < a ? a = b, 1 : 0;
}

tcT> bool ckmax(T& a, const T& b){
	return a < b ? a = b, 1 : 0;
}

const int mx = 2005;

bool ansInTrie(vb ans){
	return true;
}

struct TwoSAT{
	int N = 0; vpi edges;
	void init(int _N) { N = _N;}
	int addVar() { return N++; }
	void either(int x, int y){
		x = max(2*x, -1-2*x), y = max(2*y, -1-2*y);
		edges.emplace_back(x, y);
	}

	vpi generateEdges(){
		vpi res;
		each(e, edges){
			//e.f^1, e.s
			res.pb(mp(e.f^1, e.s));
			//e.s^1, e.f
			res.pb(mp(e.s^1, e.f));
		}
		edges.clear();
		edges.pb(mp(-1, -1)); //DON'T USE THIS
		return res;
	}
};


using ull = unsigned long long;

struct bit {
	vector<ull> data;
	void init(int n) {
		data.resize((n >> 6) + 1);
	}
	void setOne(int i) {
		data[i >> 6] |= (ull)1 << (i & 63);
	}
	int count() {
		int res = 0;
		for (int i = 0; i < sz(data); i++) {
			res += __builtin_popcountll(data[i]);
		}
		return res;
	}
	int get(int i) {
		return (data[i >> 6] >> (i & 63)) & 1;
	}
};


void operator |= (bit &a, const bit &b) {
	for (int i = 0; i < sz(a.data); i++) {
		a.data[i] |= b.data[i];
	}
}



bool andEmpty(const bit &a, const bit &b) {
	for (int i = 0; i < sz(a.data); i++) {
		if (a.data[i] & b.data[i]) {
			return false;
		}
	}
	return true;
}


bit operator &(const bit &a, const bit &b) {
	bit c;
	c.data.resize(sz(a.data));
	for (int i = 0; i < sz(a.data); i++) {
		c.data[i] = a.data[i] & b.data[i];
	}
	return c;
}


bit operator ~(const bit &a) {
	bit c;
	c.data.resize(sz(a.data));
	for (int i = 0; i < sz(a.data); i++) {
		c.data[i] = ~a.data[i];
	}
	return c;
}

bool S[mx][mx];
bit columns[mx];
bit not_columns[mx];
int nxt[mx * mx][2];
int uk = 0;
int leaves[mx * mx];


void add(int i, int M) {
	int cur = 0;
	vector<int> d;
	for (int j = 0; j < M; j++) {
		d.pb(cur);
		if (nxt[cur][S[i][j]]) {
			cur = nxt[cur][S[i][j]];
		} else {
			uk++;
			nxt[cur][S[i][j]] = uk;
			cur = uk;
		}
	}
	for (auto x: d) {
		leaves[x]++;
	}
}


void dfs(int i, vector<bit> &bl, int u = 0) {
	if (!nxt[i][0] && !nxt[i][1]) {
		return;
	}
	if (!nxt[i][0] || !nxt[i][1]) {
		int t = (nxt[i][0] ? 0: 1);
		if (!bl[u * 2].get(u * 2 + 1) && !bl[u * 2 + 1].get(u * 2)) {
			cout << -1 << '\n';
			exit(0);
		}
		dfs(nxt[i][t], bl, u + 1);
		return;
	}
	int t = 0, t1 = 1;
	int lu = u * 2, ru = u * 2 + 1;
	if (leaves[nxt[i][t]] > leaves[nxt[i][t1]]) {
		swap(t, t1);
		swap(lu, ru);
	}
	auto bl1 = bl;
	for (int i = 0; i < sz(bl1); i++) {
		if (bl1[i].get(lu) && !bl1[i].get(ru)) {
			bl1[i] |= bl1[ru];
		}
	}
	dfs(nxt[i][t], bl1, u + 1);
	bl1.clear();
	bl1.shrink_to_fit();
	swap(lu, ru);
	for (int i = 0; i < sz(bl); i++) {
		if (bl[i].get(lu) && !bl[i].get(ru)) {
			bl[i] |= bl[ru];
		}
	}
	dfs(nxt[i][t1], bl, u + 1);
}

//BEGIN RICHARD CODE

struct SCC{
	int N, ti = 0; V<vi> adj;
	vi disc, comp, stk, comps;
	void init(int _N){
		N = _N, adj.rsz(N), disc.rsz(N), comp.rsz(N, -1);
	}
	void ae(int x, int y){
		// cout << "N = " << N << "\n";
		// cout << "ADDING: " << x << " " << y << "\n"; cout.flush();
		adj[x].pb(y);
	}
	int dfs(int x){
		// cout << "HI" << x << "\n"; cout.flush();
		int low = disc[x] = ++ti; stk.pb(x);
		each(y, adj[x]) if(comp[y] == -1)
			ckmin(low, disc[y]?:dfs(y));
		// cout << "HERE!" << "\n";
		if(low == disc[x]){
			// cout << "HERE2!" << "\n";
			comps.pb(x); for(int y = -1; y != x;)
				comp[y = stk.bk] = x, stk.pop_back();
		}
		// cout << "HERE3!" << "\n";
		return low;
	}

	void gen(){
		F0R(i,N) if(!disc[i]) dfs(i);
		reverse(all(comps));

		// cout << "END" << "\n"; cout.flush();
	}
};

vector<bit> DP;
vector<bit> getReachability(vpi edges, int N){
	SCC scc; scc.init(2*N);
	for(auto u: edges){
		scc.ae(u.f, u.s);	
	}
	scc.gen();

	V<vi> comp_adj(2*N);
	for(auto u: edges){
		comp_adj[scc.comp[u.f]].pb(scc.comp[u.s]);
	}

	DP = vector<bit>(2*N);
	for(int i = 0; i < 2*N; i++){
		DP[i].init(2 * N);
	}
	for(int i = 0; i < 2*N; i++){
		DP[scc.comp[i]].setOne(i);
	}

	for(int comps_ind = sz(scc.comps)-1; comps_ind >= 0; comps_ind--){
		int comp = scc.comps[comps_ind];
		if (comp_adj[comp].empty()) {
			continue;
		}
		sort(all(comp_adj[comp]));
		comp_adj[comp].resize(distance(comp_adj[comp].begin(), unique(all(comp_adj[comp]))));
		for(auto u: comp_adj[comp]){
			if(comp == u) continue;
			DP[comp]|=DP[u];
		}
	}

	for(int i = 0; i < 2*N; i++){
		if(scc.comp[i] != i){
			DP[i] |= DP[scc.comp[i]];
		}
	}

	return DP;
}

int main(){
	cin.tie(0)->sync_with_stdio(0);


	int N, M; cin >> N >> M;
	for(int i = 0; i < N; i++){
		string row; cin >> row;
		for(int j = 0; j < M; j++){
			S[i][j] = row[j]-'0';
		}
		add(i, M);
	}
	for(int j = 0; j < M; j++){
		columns[j].init(N);
		not_columns[j].init(N);
	}
	for(int i = 0; i < N; i++){
		for(int j = 0; j < M; j++){
			if (S[i][j]) {
				columns[j].setOne(i);
			}
		}
	}

	bit MASK;
	MASK.init(N);
	for(int i = 0; i < N; i++){
		MASK.setOne(i);
	}
	for(int j = 0; j < M; j++){
		not_columns[j] = ~columns[j]&MASK;
	}

	

	V<vi> ans;
	TwoSAT twosat; twosat.init(M);

	// for(int col = 0; col < M; col++){
	// 	string str;
	// 	for(int i = 0; i < N; i++){
	// 		str+=char('0' + columns[col][i]);
	// 	}
	// 	cout << "col: " << col <<": "<< str << "\n";
	// }

	for(int j = 0; j < M; j++){
		//check whether the entire column is 1, or all 0
		if(columns[j].count() == N){ //1 is salvation
			ans.pb(vi{j, j, 4});
			twosat.either(j, j);
		}
		else if(columns[j].count() == 0){
			ans.pb(vi{j, j, 1});
			twosat.either(~j, ~j);
		}

		for(int j2 = j+1; j2 < M; j2++){
			//check whether 00 appears
			if(andEmpty(not_columns[j], not_columns[j2])){
				//does not appear
				ans.pb(vi{j, j2, 4});
				twosat.either(j, j2);
			}
			//check 01
			if(andEmpty(not_columns[j], columns[j2])){
				//does not appear
				ans.pb(vi{j, j2, 2});
				twosat.either(j, ~j2);
			}
			//check 10
			if(andEmpty(columns[j], not_columns[j2])){
				//does not appearn
				ans.pb(vi{j, j2, 3});
				twosat.either(~j, j2);
			}

			//check 11
			if(andEmpty(columns[j], columns[j2])){
				//does not appear
				ans.pb(vi{j, j2, 1});
				twosat.either(~j, ~j2);
			}
		}
	}

	vpi edges = twosat.generateEdges();
	vector<bit> bl = getReachability(edges, M);
	// vector<bit> bl(2 * N);
	// for (int i = 0; i < 2 * N; i++) {
	// 	bl[i][i] = true;
	// }

	dfs(0, bl);

	string OUTPUT = "";
	OUTPUT += to_string(sz(ans)) + "\n";
	for(auto u: ans){
		OUTPUT+=to_string(u[0]) + " "  + to_string(u[1]) + " " + to_string(u[2]) + "\n";
	}
	cout << OUTPUT << "\n";
}