#include <bits/stdc++.h> 

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

struct DSU
{
	int n;
	VI p, sz;
	void init(int _n)
	{
		n = _n;
		p.resize(n);
		iota(ALL(p), 0);
		sz.assign(n, 1);
	}
	int find(int v)
	{
		if(v == p[v])
			return v;
		return p[v] = find(p[v]);
	}
	bool unite(int u, int v)
	{
		u = find(u);
		v = find(v);
		if(u == v)
			return false;
		if(sz[u] > sz[v])
			swap(u, v);
		p[u] = v;
		sz[v] += sz[u];
		return true;
	}
};

const int N = 1 << 11;
int d[N][N];
vector<PII> g[N];

int dist[N];

void dfs(int v, int p, int di)
{
	dist[v] = di;
	for(auto [to, w] : g[v])
	{
		if(to != p)
			dfs(to, v, di + w);
	}
}



void solve(int n)
{
	vector<tuple<int, int, int>> vals(n * n);
	FOR(i, 0, n)
	{
		FOR(j, 0, n)
		{
			cin >> d[i][j];
			vals[i * n + j] = {d[i][j], i, j};
		}
	}
	sort(ALL(vals));
	DSU D;
	D.init(n);
	for(auto [dis, i, j] : vals)
	{
		if(i == j)
			continue;
		if(!D.unite(i, j))
			continue;
		cout << i + 1 << " " << j + 1 << " " << dis << "\n";
		
		g[i].PB({j, dis});
		g[j].PB({i, dis});
	}
	PII edge = {-1, -1};	
	
	FOR(i, 0, n)
	{
		dfs(i, -1, 0);
		
		
		FOR(j, 0, n)
		{
			if(dist[j] != d[i][j])
			{
				if(edge.F == -1 || d[edge.F][edge.S] > d[i][j])
					edge = {i, j};
			}
		}
	}
	if(edge == MP(-1, -1))
		edge = MP(0, 1);
	
	cout << edge.F + 1 << " " << edge.S + 1 << " " << d[edge.F][edge.S] << "\n";
	cout << "\n";
	FOR(i, 0, n)
		g[i].clear();
}



int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	
	int n;
	while(cin >> n)
		solve(n);
	
	return 0;
}