#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef array<int, 3> ai3;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
const int Mod = 1e9 + 7;
inline int sign(int a){ return (a&1) ? (Mod-1) : 1; }
inline void uadd(int &a, int b){ a += b-Mod; a += (a>>31) & Mod; }
inline void usub(int &a, int b){ a -= b, a += (a>>31) & Mod; }
inline void umul(int &a, int b){ a = (int)(1ll * a * b % Mod); }
inline int add(int a, int b){ a += b-Mod; a += (a>>31) & Mod; return a; }
inline int sub(int a, int b){ a -= b, a += (a>>31) & Mod; return a; }
inline int mul(int a, int b){ a = (int)(1ll * a * b % Mod); return a; }
int qpow(int b, ll p){ int ret = 1; while(p){ if(p&1) umul(ret, b); umul(b, b), p >>= 1; } return ret; }
const int fN = 66666;
int fact[fN], invfact[fN], inv[fN];
void initfact(int n){
	fact[0] = 1; for(int i = 1; i <= n; ++i) fact[i] = mul(fact[i-1], i);
	invfact[n] = qpow(fact[n], Mod-2); for(int i = n; i > 0; --i) invfact[i-1] = mul(invfact[i], i);
	for(int i = 1; i <= n; ++i) inv[i] = mul(invfact[i], fact[i-1]);
}
int binom(int n, int m){ return (m < 0 || m > n) ? 0 : mul(fact[n], mul(invfact[m], invfact[n-m])); }
const double pi = acos(-1);
inline void chmax(int &a, int b){ (b>a) ? (a=b) : 0; }
inline void chmin(int &a, int b){ (b<a) ? (a=b) : 0; }
inline void chmax(ll &a, ll b){ (b>a) ? (a=b) : 0; }
inline void chmin(ll &a, ll b){ (b<a) ? (a=b) : 0; }

int n, w[255][255], cid[255][255][255], cc = 0;
array<int, 3> cs[1010];
vi to[1010];
int fa[1010];
int dp0[1010][3], dp1[1010][3][2], go[1010][3];
void dfs0(int id){
	//cout << "dfs0 " << id << " " << fa[id] << endl;
	array<int, 3> c = cs[id];
	for(auto u : to[id]){
		if(u == fa[id]) continue;
		int t;
		t = cid[c[0]][c[1]][u], fa[t] = c[2], dfs0(t);
		t = cid[c[1]][c[2]][u], fa[t] = c[0], dfs0(t);
		t = cid[c[2]][c[0]][u], fa[t] = c[1], dfs0(t);
	}
}

int getdp1(int s, int t, int r, bool sp = 0);

int getdp0(int s, int t, int r){
	int id = cid[s][t][r];
	array<int, 3> c = cs[id];
	int sid = 0, tid = 0;
	while(c[sid] != s) ++sid;
	while(c[tid] != t) ++tid;
	if(sid > tid) swap(s, t), swap(sid, tid);
	int dpj = (sid == 0 ? tid-1 : 2);
	int &ans = dp0[id][dpj];
	if(ans >= 0) return ans;
	ans = w[s][t];
	for(auto u : to[id]){
		if(u == fa[id]) continue;
		chmax(ans, getdp1(s, t, u));
		chmax(ans, max(getdp0(s, u, r), w[s][u]) + max(getdp0(u, t, r), w[u][t]));
		chmax(ans, max(getdp0(s, u, r), w[s][u]) + max(getdp0(u, t, s), w[u][t]));
		chmax(ans, max(getdp0(s, u, t), w[s][u]) + max(getdp0(u, t, r), w[u][t]));
	}
	//cout << "getdp0 " << s << " " << t << " " << r << " = " << ans << endl;
	return ans;
}

int getgo(int s, int t, int r){
	int id = cid[s][t][r];
	array<int, 3> c = cs[id];
	int sid = 0;
	while(c[sid] != s) ++sid;
	int &ans = go[id][sid];
	if(ans >= 0) return ans;

	int u = -1;
	for(auto v : to[id]){
		if(v == fa[id]) continue;
		u = v;
	}

	if(u < 0) return ans = 0;

	ans = w[s][u];
	chmax(ans, max(getgo(s, t, u), getgo(s, r, u)));
	chmax(ans, getdp0(s, u, t) + max(getgo(u, s, r), getgo(u, t, r)));
	chmax(ans, getdp0(s, u, r) + max(getgo(u, s, t), getgo(u, t, r)));
	//cout << "getgo " << s << " " << t << " " << r << " = " << ans << endl;
	return ans;
}

int getdp1(int s, int t, int r, bool sp){
	int id = cid[s][t][r];
	array<int, 3> c = cs[id];
	int sid = 0, tid = 0;
	while(c[sid] != s) ++sid;
	while(c[tid] != t) ++tid;
	if(sid > tid) swap(s, t), swap(sid, tid);
	int dpj = (sid == 0 ? tid-1 : 2);
	int &ans = dp1[id][dpj][sp];
	if(ans >= 0) return ans;

	vi ps = (vi){cs[id][0], cs[id][1], cs[id][2]};
	for(auto u : to[id]){
		if(u == fa[id]) continue;
		ps.push_back(u);
	}

	//cout << "-------------------getdp1 " << s << " " << t << " " << r << "----------------" << endl;

	if((int)ps.size() == 3){
		if(sp){
			ans = w[s][t] + w[t][r] + w[r][s] - min({w[s][t], w[t][r], w[r][s]});
		} else {
			ans = max(w[s][t], w[s][r] + w[r][t]);
		}
		return ans;
	}

	if(sp){
		chmax(ans, getdp1(ps[0], ps[1], ps[3], 1));
		chmax(ans, getdp1(ps[1], ps[2], ps[3], 1));
		chmax(ans, getdp1(ps[2], ps[0], ps[3], 1));
	}

	array< array< array<int, 4>, 8 >, 16 > dp;
	rep(i, 16) rep(j, 8) rep(k, 4) dp[i][j][k] = -inf;
	dp[1<<sid][0][sid] = 0;
	if(sp){
		rep(i, 4) dp[1<<i][0][i] = 0;
		rep(nid, 3){
			int u = nid, v = (nid+1) % 3;
			chmax(dp[1<<v][1<<nid][v], getgo(ps[u], ps[v], ps[3]));
			chmax(dp[1<<u][1<<nid][u], getgo(ps[v], ps[u], ps[3]));
			chmax(dp[1<<3][1<<nid][3], getgo(ps[u], ps[3], ps[v]));
		}
	}
	rep(mask, 16) rep(ts, 8) rep(i, 4) if(dp[mask][ts][i] >= 0) rep(j, 4) if(!((mask>>j) & 1)){
		//cout << s << t << r << " | " << (bitset<4>)mask << " " << (bitset<3>)ts << " " << i << ": " << dp[mask][ts][i] << endl;
		chmax(dp[mask | (1<<j)][ts][j], dp[mask][ts][i] + w[ps[i]][ps[j]]);
		int u = i, v = j;
		if(u > v) swap(u, v);
		if(v != 3){
			int nid = (u == 0 && v == 2) ? 2 : u;
			if(!((ts>>nid) & 1)){
				chmax(dp[mask | (1<<j)][ts | (1<<nid)][j], dp[mask][ts][i] + getdp0(ps[u], ps[v], ps[3]));
				if(!((mask>>3) & 1))
					chmax(dp[mask | (1<<j) | (1<<3)][ts | (1<<nid)][j], dp[mask][ts][i] + getdp1(ps[u], ps[v], ps[3]));
			}
		} else {
			int nid = u, ru = (nid+1) % 3;
			if(!((ts>>nid) & 1)){
				chmax(dp[mask | (1<<j)][ts | (1<<nid)][j], dp[mask][ts][i] + getdp0(ps[u], ps[v], ps[ru]));
				if(!((mask>>ru) & 1))
					chmax(dp[mask | (1<<j) | (1<<ru)][ts | (1<<nid)][j], dp[mask][ts][i] + getdp1(ps[u], ps[v], ps[ru]));
			}
			nid = (u+2) % 3, ru = nid;
			//cout << nid << " " << ru << endl;
			if(!((ts>>nid) & 1)){
				chmax(dp[mask | (1<<j)][ts | (1<<nid)][j], dp[mask][ts][i] + getdp0(ps[u], ps[v], ps[ru]));
				if(!((mask>>ru) & 1)){
					chmax(dp[mask | (1<<j) | (1<<ru)][ts | (1<<nid)][j], dp[mask][ts][i] + getdp1(ps[u], ps[v], ps[ru]));
				}
			}
		}
	}
	//rep(mask, 16) rep(ts, 8) rep(i, 4) if(dp[mask][ts][i] >= 0)
	//	cout << "? " << s << t << r << " | " << (bitset<4>)mask << " " << (bitset<3>)ts << " " << i << ": " << dp[mask][ts][i] << endl;

	ans = 0;
	rep(mask, 16) rep(ts, 8) chmax(ans, dp[mask][ts][tid]);
	if(sp){
		rep(mask, 16) rep(ts, 8) rep(i, 4) chmax(ans, dp[mask][ts][i]);
		rep(mask, 16) rep(ts, 8) rep(nid, 3) if(!((ts>>nid) & 1)){
			int u = nid, v = (nid+1) % 3;
			chmax(ans, dp[mask][ts][u] + getgo(ps[u], ps[v], ps[3]));
			chmax(ans, dp[mask][ts][v] + getgo(ps[v], ps[u], ps[3]));
			chmax(ans, dp[mask][ts][3] + getgo(ps[3], ps[v], ps[u]));
		}
	}
	//cout << "! " << ans << endl;
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	
	cin >> n;
	memset(w, 0x3f, sizeof(w));
	rep(i, 3*(n-2)){
		int u, v, c;
		cin >> u >> v >> c;
		--u, --v;
		w[u][v] = w[v][u] = c;
	}

	if(n == 3){
		cout << w[0][1] + w[1][2] + w[2][0] - min({w[0][1], w[1][2], w[2][0]}) << "\n";
		return 0;
	}

	memset(cid, -1, sizeof(cid));
	rep(i, n) rep(j, i) if(w[i][j] < inf) rep(k, j) if(w[j][k] < inf && w[k][i] < inf){
		cs[cc] = {k, j, i};
		cid[i][j][k] = cid[i][k][j] = cid[j][i][k] = cid[j][k][i] = cid[k][i][j] = cid[k][j][i] = cc++;
	}

	int rt = 0;
	rep(i, cc){
		array<int, 3> c = cs[i];
		rep(u, n) if(cid[c[0]][c[1]][u] >= 0 && cid[c[1]][c[2]][u] >= 0 && cid[c[2]][c[0]][u] >= 0) to[i].push_back(u);
		if((int)to[i].size() == 1) rt = i;
	}

	//rep(i, n) rep(j, n) rep(k, n) cout << i << " " << j << " " << k << ": " << cid[i][j][k] << endl;

	//rep(i, cc) cout << i << ": " << cs[i][0] << " " << cs[i][1] << " " << cs[i][2] << endl;
	//rep(i, cc){
	//	cout << i << " to ";
	//	for(auto u : to[i]) cout << u << " ";
	//	cout << endl;
	//}
	//cout << rt << endl;

	fa[rt] = -1, dfs0(rt);

	memset(dp0, 0xc0, sizeof(dp0)), memset(dp1, 0xc0, sizeof(dp1)), memset(go, 0xc0, sizeof(go));
	
	cout << getdp1(cs[rt][0], cs[rt][1], cs[rt][2], 1) << "\n";

	return 0;
}