package main

import (
	"fmt"
)

func sub(N int, maxp [][]int, maxjmaxp []int, maxijmaxp *int, tmps []int, pair, rest int) {
	for i := 0; i < N; i++ {
		tmps[i] = maxp[i][pair] + 1
	}
	tmp := maxp[rest][rest] + 1

	for i := 0; i < N; i++ {
		maxp[i][pair] = maxjmaxp[i]
		maxp[pair][i] = maxjmaxp[i]
		maxp[i][rest] = maxjmaxp[i]
		maxp[rest][i] = maxjmaxp[i]
	}
	for i := 0; i < N; i++ {
		if maxjmaxp[pair] < maxjmaxp[i] {
			maxjmaxp[pair] = maxjmaxp[i]
		}
		if maxjmaxp[rest] < maxjmaxp[i] {
			maxjmaxp[rest] = maxjmaxp[i]
		}
	}

	maxp[pair][pair] = *maxijmaxp
	maxp[rest][pair] = *maxijmaxp
	maxp[pair][rest] = *maxijmaxp
	maxjmaxp[pair] = *maxijmaxp
	maxjmaxp[rest] = *maxijmaxp

	for i := 0; i < N; i++ {
		if maxp[i][rest] < tmps[i] {
			maxp[i][rest] = tmps[i]
			maxp[rest][i] = tmps[i]
		}
		if maxjmaxp[i] < tmps[i] {
			maxjmaxp[i] = tmps[i]
		}
		if maxjmaxp[rest] < tmps[i] {
			maxjmaxp[rest] = tmps[i]
		}
		if *maxijmaxp < tmps[i] {
			*maxijmaxp = tmps[i]
		}
	}

	if maxp[pair][pair] < tmp {
		maxp[pair][pair] = tmp
	}
	if maxjmaxp[pair] < tmp {
		maxjmaxp[pair] = tmp
	}
	if *maxijmaxp < tmp {
		*maxijmaxp = tmp
	}
}

func main() {
	var N int
	fmt.Scanf("%d", &N)

	maxp := make([][]int, N)
	for i := 0; i < N; i++ {
		maxp[i] = make([]int, N)
	}
	maxjmaxp := make([]int, N)
	maxijmaxp := 0
	maxpbias := -1000000000
	tmps := make([]int, N)

	var A0, A1 int
	fmt.Scanf("%d%d", &A0, &A1)
	A0--
	A1--

	maxp[A0][A1] = 1000000000
	maxp[A1][A0] = 1000000000
	maxjmaxp[A0] = 1000000000
	maxjmaxp[A1] = 1000000000
	maxijmaxp = 1000000000

	for n := 1; n < N; n++ {
		var A3nm1, A3n, A3np1 int
		fmt.Scanf("%d%d%d", &A3nm1, &A3n, &A3np1)
		A3nm1--
		A3n--
		A3np1--

		if A3nm1 == A3n && A3n == A3np1 {
			maxpbias++

			for i := 0; i < N; i++ {
				if maxp[i][A3nm1] < maxjmaxp[i]-1 {
					maxp[i][A3nm1] = maxjmaxp[i] - 1
					maxp[A3nm1][i] = maxjmaxp[i] - 1
				}
			}
			for i := 0; i < N; i++ {
				if maxjmaxp[A3nm1] < maxjmaxp[i]-1 {
					maxjmaxp[A3nm1] = maxjmaxp[i] - 1
				}
			}

			if maxp[A3nm1][A3nm1] < maxijmaxp-1 {
				maxp[A3nm1][A3nm1] = maxijmaxp - 1
			}
			if maxjmaxp[A3nm1] < maxijmaxp-1 {
				maxjmaxp[A3nm1] = maxijmaxp - 1
			}
		} else if A3nm1 == A3n {
			sub(N, maxp, maxjmaxp, &maxijmaxp, tmps, A3nm1, A3np1)
		} else if A3n == A3np1 {
			sub(N, maxp, maxjmaxp, &maxijmaxp, tmps, A3n, A3nm1)
		} else if A3np1 == A3nm1 {
			sub(N, maxp, maxjmaxp, &maxijmaxp, tmps, A3np1, A3n)
		} else {
			tmp0 := maxp[A3np1][A3np1] + 1
			tmp1 := maxp[A3nm1][A3nm1] + 1
			tmp2 := maxp[A3n][A3n] + 1

			for i := 0; i < N; i++ {
				maxp[i][A3nm1] = maxjmaxp[i]
				maxp[A3nm1][i] = maxjmaxp[i]
				maxp[i][A3n] = maxjmaxp[i]
				maxp[A3n][i] = maxjmaxp[i]
				maxp[i][A3np1] = maxjmaxp[i]
				maxp[A3np1][i] = maxjmaxp[i]
			}
			for i := 0; i < N; i++ {
				if maxjmaxp[A3nm1] < maxjmaxp[i] {
					maxjmaxp[A3nm1] = maxjmaxp[i]
				}
				if maxjmaxp[A3n] < maxjmaxp[i] {
					maxjmaxp[A3n] = maxjmaxp[i]
				}
				if maxjmaxp[A3np1] < maxjmaxp[i] {
					maxjmaxp[A3np1] = maxjmaxp[i]
				}
			}

			maxp[A3nm1][A3n] = maxijmaxp
			maxp[A3n][A3nm1] = maxijmaxp
			maxp[A3n][A3np1] = maxijmaxp
			maxp[A3np1][A3n] = maxijmaxp
			maxp[A3np1][A3nm1] = maxijmaxp
			maxp[A3nm1][A3np1] = maxijmaxp
			maxjmaxp[A3nm1] = maxijmaxp
			maxjmaxp[A3n] = maxijmaxp
			maxjmaxp[A3np1] = maxijmaxp

			if maxp[A3nm1][A3n] < tmp0 {
				maxp[A3nm1][A3n] = tmp0
				maxp[A3n][A3nm1] = tmp0
			}
			if maxjmaxp[A3nm1] < tmp0 {
				maxjmaxp[A3nm1] = tmp0
			}
			if maxjmaxp[A3n] < tmp0 {
				maxjmaxp[A3n] = tmp0
			}
			if maxijmaxp < tmp0 {
				maxijmaxp = tmp0
			}

			if maxp[A3n][A3np1] < tmp1 {
				maxp[A3n][A3np1] = tmp1
				maxp[A3np1][A3n] = tmp1
			}
			if maxjmaxp[A3n] < tmp1 {
				maxjmaxp[A3n] = tmp1
			}
			if maxjmaxp[A3np1] < tmp1 {
				maxjmaxp[A3np1] = tmp1
			}
			if maxijmaxp < tmp1 {
				maxijmaxp = tmp1
			}

			if maxp[A3np1][A3nm1] < tmp2 {
				maxp[A3np1][A3nm1] = tmp2
				maxp[A3nm1][A3np1] = tmp2
			}
			if maxjmaxp[A3np1] < tmp2 {
				maxjmaxp[A3np1] = tmp2
			}
			if maxjmaxp[A3nm1] < tmp2 {
				maxjmaxp[A3nm1] = tmp2
			}
			if maxijmaxp < tmp2 {
				maxijmaxp = tmp2
			}
		}
	}

	var A3Nm1 int
	fmt.Scanf("%d", &A3Nm1)
	A3Nm1--

	maxp[A3Nm1][A3Nm1]++
	if maxijmaxp < maxp[A3Nm1][A3Nm1] {
		maxijmaxp = maxp[A3Nm1][A3Nm1]
	}
	fmt.Printf("%d\n", maxijmaxp+maxpbias)
}


Measured memory_bytes: 35660