#include <bits/stdc++.h> 
using namespace std; 
typedef long long int ll;
#define MAX 10000007;
// // // ll p[1000000000001];
// // ll power(ll x, ll y){
// // 	int res = 1;
// // 	// x = x % mx;
// // 	while (y > 0){
// // 		if (y & 1)
// // 			res = (res * x)  % MAX;
// // 		y = y >> 1;
// // 		x = (x * x) % MAX;
// // 	}
// // 	return res;
// // }
// // void pre(){
// // 	for (ll i = 1; i <= 1000000000001; i++){
// // 		for (ll j = 1; j <= sqrt(i); j ++)
// // 		{
// // 			if(i % j == 0)
// // 				p[i] = (p[i] + j) % MAX;
// // 		}
// // 	}
// // }
// // vector<bool> p(3000,true);
// // void sieve(){
	
// // 	// vector<int> primes;
// // 	p[0] = p[1] = false;
// // 	// int cnt = 0;
// // 	ll row = 1;
// // 	ll temp = 1;
// // 	for (int i = 2; i * i <=(3000); i++){
// // 		if (p[i] == true){
// // 			for (int j = i * i; j <= 3000; j += i){
// // 				p[j] = false;
// // 			}
// // 		}
// // 	}
// // }
// // ll arr[3000];
// // void precalc(){
// // 	for (int i = 1; i <= 3000; i++){
// // 		for (int j = 2; j <= i; j++){
// // 			if (p[j] == 1 && i % j == 0) 
// // 				arr[i]++;
// // 		}
// // 	}
// // }
// // void pattern(){
// // 	for (int i = 1; i <= 100000000; i++	)
// // 	{
// // 		if ()
// // 	}
// // }
// // ll binomial(ll n, ll k){
// // 	ll c[n+1][k+1];
// // 	ll i,j;
// // 	for (i = 0; i <= n; i++){
// // 		for (j = 0; j <= min(i,k); j++){
// // 			if (j == 0 || j == i){
// // 				c[i][j] = 1;
// // 			}
// // 			else
// // 			{
// // 				c[i][j] = (c[i-1][j-1] + c[i-1][j]) % MAX;
// // 			}
			
// // 		}
// // 	}
// // 	return c[n][k];
// // }
// // ll gcd(ll a, ll b, ll &x, ll &y) {
// //     if (b == 0) {
// //         x = 1;
// //         y = 0;
// //         return a;
// //     }
// //     ll x1, y1;
// //     ll d = gcd(b, a % b, x1, y1);
// //     x = y1;
// //     y = x1 - y1 * (a / b);
// //     return d;
// // }
// // vector<int> arr(1000000000,0);
// // void fib(){
// // 	arr[0] = 0; arr[1] = 1;
// // 	for (int i = 2; i <= 1000000000; i++){
// // 		arr[i] = (arr[i-1] + arr[i-2]) % MAX;
// // 	}
// // }
// //deterministic version to check prime
// // typedef int64_t u64;
// // typedef __uint128_t u128;
// // u64 binpower(u64 base, u64 e, u64 mod) {
// //     u64 result = 1;
// //     base %= mod;
// //     while (e) {
// //         if (e & 1)
// //             result = (u128)result * base % mod;
// //         base = (u128)base * base % mod;
// //         e >>= 1;
// //     }
// //     return result;
// // }
// // bool check_composite(u64 n, u64 a, u64 d, int s) {
// //     u64 x = binpower(a, d, n);
// //     if (x == 1 || x == n - 1)
// //         return false;
// //     for (int r = 1; r < s; r++) {
// //         x = (u128)x * x % n;
// //         if (x == n - 1)
// //             return false;
// //     }
// //     return true;
// // };
// // bool MillerRabin(int64_t n) { // returns true if n is prime, else returns false.
// //     if (n < 2)
// //         return false;
// //     int r = 0;
// //     int64_t d = n - 1;
// //     while ((d & 1) == 0) {
// //         d >>= 1;
// //         r++;
// //     }
// //     for (int a : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}) {
// //         if (n == a)
// //             return true;
// //         if (check_composite(n, a, d, r))
// //             return false;
// //     }
// //     return true;
// // }
// // wheeler's factorization method
// // map <long long int,long long int> v;
// // void factors(long long int n){
	
// // 	while (n % 2 == 0){
// // 		v[2]++;
// // 		n /= 2;
// // 	}
// // 	for (long long int i = 3; i <= sqrt(n); i += 2){
// // 		while (n % i == 0)
// // 		{
// // 			v[i]++;
// // 			n /= i;
// // 		}
// // 	}
// // 	if (n > 1)	v[n]++;
// // 	// return v;
// // }
// //euler totient function to calculate phi which is the no. of positive integer from [1...n] which is coprime to n;
// // vector<int> phi(100000000 + 1);
// // void phi_1_to_n(int n) {
    
// //     phi[0] = 0;
// //     phi[1] = 1;
// //     for (int i = 2; i <= n; i++)
// //         phi[i] = i - 1;

// //     for (int i = 2; i <= n; i++)
// //         for (int j = 2 * i; j <= n; j += i)
// //               phi[j] -= phi[i];
// // }
// // int phi(int n) {
// //     int result = n;
// //     for (int i = 2; i * i < n; i++) {
// //         if (n % i == 0) {
// //             while (n % i == 0)
// //                 n /= i;
// //             result -= result / i;
// //         }
// //     }
// //     if (n > 1)
// //         result -= result / n;
// //     return result;
// // }

int main() 
{ 
    int n, cnt = 0; cin >> n;

    while (n--){
        int a,b; cin >> a >> b;

        if (a == b) cnt++;
        else if (cnt == 3)  break;
        else cnt = 0;
    }
    
    if (cnt >= 3) cout << "Yes";
    else cout << "No";

} 


Measured memory_bytes: 3620