#pragma warning(disable: 4996)
#include <string>
#include <vector>
#include <iostream>
#include <cstdio>
#include <sstream>
#include <fstream>
#include <math.h>
#include <algorithm>
#include <map>
#include <bitset>
#include <queue>

using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < (n); i++)
const double GS = 1e-7;

int main() {
	int n;
	cin >> n;
	vector<int>x(n), y(n);
	rep(i, n)cin >> x[i] >> y[i];
	for (int i = 0; i < n - 2; i++) {
		for (int j = i + 1; j < n - 1; j++) {
			for (int k = j + 1; k < n; k++) {
				int tmp = min(y[i], y[j]);
				int mi = min(y[k], tmp);
				double k1 = 0, k2 = 0;
				if (mi == y[i]) {
					 k1 = (double)(y[j] - y[i]) / (x[j] - x[i]);
					 k2 = (double)(y[k] - y[i]) / (x[k] - x[i]);
				}
				else if (mi == y[j]) {
					 k1 = (double)(y[i] - y[j]) / (x[i] - x[j]);
					 k2 = (double)(y[k] - y[j]) / (x[k] - x[j]);
				}
				else {
					 k1 = (double)(y[i] - y[k]) / (x[i] - x[k]);
					 k2 = (double)(y[j] - y[k]) / (x[j] - x[k]);
				}
				if (abs(k1 - k2) <= GS || ((x[i] == x[j]) && (x[k] == x[i]))) {
					cout << "Yes" << endl;
					//cout << i << j << k << endl;
					//printf("%.16f", k1);
					//cout << endl;
					//printf("%.16f", k2);
					return 0;
				}
			}
		}
	}
	cout << "No" << endl;
	
	return 0;
}
// DeNsE - EcLiPsE //
// WHAT is DEAD may NEVER die //

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <cmath>
#include <iomanip>
#include <set>
#include <cstring>
#include <stack>
#include <sstream>
#include <queue>
#include <unordered_set>
#include <cstdlib>

using namespace std;

#define nitro ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define int long long
#define double long double
#define endl " \n"

const int inf = (1ll << 62) - 1;
const int mod = 998244353;
const int N = 25;
const double pi = 3.14159265358979323846;

int bPow(int a, int b){
    int res = 1;
    while(b) {
        if (b & 1) {
            res = (res * a) % mod;
        }
        b >>= 1;
        a = (a * a) % mod;
    }
    return res % mod;
}

int gcd(int a, int b)
{
    if(a < b)
        swap(a, b);
    if (b == 0)
        return a;
    return gcd(b, a % b);

}

vector<int> fact(N, 0ll);
void factorial(){
    fact[0] = 1, fact[1] = 1;
    for(int i = 2; i < N; i++){
        fact[i] = (fact[i - 1] * i) % mod;
    }
}

int ncr(int n, int r){
    if(r > n)
        return 0;
    int ans = fact[n] % mod;
    ans *= bPow(fact[r], mod - 2) % mod;
    ans %= mod;
    ans *= bPow(fact[n - r], mod - 2) % mod;
    ans %= mod;
    return ans;
}

vector<int> primes(N, -1);
void sieve(){
    iota(primes.begin(), primes.end(), 0);
    for (int i = 2; i * i <= N; ++i) {
        if(primes[i] == i){
            for (int j = 2 * i; j < N; j += i) {
                primes[j] = i;
            }
        }
    }
}

void solve() {
    int n;
    cin >> n;
    vector<pair<int, int>> pts;
    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        pts.emplace_back(x, y);
    }
    for (int i = 0; i < n; ++i) {
        int x = pts[i].first, y = pts[i].second;
        map<double, int> slopes;
        bool haveInfinite = false;
        for (int j = i + 1; j < n; ++j) {
            int dx = pts[j].first - x, dy = pts[j].second - y;
            if(dx == 0 and haveInfinite) {
                cout << "Yes" << endl;
                return;
            }else if(dx != 0){
                double val = (double) dy / (double) dx;
                if(slopes.count(val)){
                    cout << "Yes" << endl;
                    return;
                }
                slopes[val]++;
            }
            if(dx == 0)
                haveInfinite = true;
        }
    }
    cout << "No" << endl;
}

signed main(){
    nitro
    int tc = 1, test = 1;
    //cin >> tc;
    while(tc--){
        //cout << "Case #" << test++ << ": ";
        solve();
    }
}