#include <bits/stdc++.h> 
    #include<ext/pb_ds/assoc_container.hpp> 
    #include<ext/pb_ds/tree_policy.hpp>
    using namespace __gnu_pbds;
    using namespace std;
    template <typename T>
    using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
    #define int long long  
    typedef long double ld;
    #define pb push_back
    #define f(i,a,b) for(int i=a;i<b;i++)
    #define fd(i,a,b) for(int i=a-1;i>=b;i--)
   #define print(a,n) f(i,0,n){cout<<a[i]<<" ";}
    #define pf push_front
    #define fi first
    #define se second
    #define ps(x,y)         fixed<<setprecision(y)<<x
    #define INF 1e10
    const double pi=3.14159265358979323;
    const int mod=998244353;
    const int MAX=1000000+5;
    int p[MAX]={0};

     int gcd(int a, int b) 
    { 
    if (b == 0) 
        return a; 
    return gcd(b, a % b);  
      
    } 
    void swap(int &a,int& b)
    {
      int temp=a;
      a=b;
      b=temp;
    } 
    int  binpow(int  a,int  b) 
    {
    int res = 1;
    while (b > 0) {
        if (b%2 == 1)
            res = (res * a)%mod;
        a = (a* a)% mod;
        b >>= 1;
    }
    return res;
}
    int modinv(int y)
    {
        return binpow(y,mod-2);
    }

    int fact[500000+5];
    void precal()
    {
    fact[0]=1;
    for(int i=1;i<500000+5;i++)
    {
        fact[i]=(i*fact[i-1])%mod;
    }
}
    bool isPrime(int n) 
    { 
    // Corner cases 
    if (n <= 1) 
        return false; 
    if (n <= 3) 
        return true; 
   
    if (n % 2 == 0 || n % 3 == 0) 
        return false; 
  
    for (int i = 5; i * i <= n; i = i + 6) 
        if (n % i == 0 || n % (i + 2) == 0) 
            return false; 
  
    return true; 
    } 
    int mm[200000+5]={0};
    int pos[200000+5]={0};
    bool flag=true;
    int pr[200000+5]={0};
    vector<pair<int ,int>> vv;
    int vis[200000+5]={0};
     vector<vector<int >> adj;
     queue<int > q;
     int dfs(int j)
     {
        vis[j]=1;
        pos[j]=1;
        for(auto i:adj[j])
        {
            if(vis[i]==0)
            {
               pos[j]+=dfs(i);
            }
        }
        return pos[j];
     }
     /*void bfs(int j)
     {
        q.push(j);
        while(!q.empty())
        {
            int r=q.front();
            q.pop();
        for(auto i:adj[r])
        {
            if(vis[i]==0)
            {
                pr[i]=r;
                vis[i]=1;
                q.push(i);
            }
        }
        }        
     }*/
    signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);  
    /*#ifndef ONLINE_JUDGE
      if(fopen("INPUT.txt","r"))
      {
      freopen ("INPUT.txt" , "r" , stdin);
      freopen ("OUTPUT.txt" , "w" , stdout); 
      }
    #endif*/
    int t=1; 
   // cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        int a[n][2];
        f(i,0,n)
        {
            cin>>a[i][0]>>a[i][1];
        }
        bool flag=false;
        f(i,0,n-2)
        {
            f(j,i+1,n-1)
            {
                f(k,j+1,n)
                {
                    if((a[k][0]-a[i][0])*(a[j][1]-a[i][1])==(a[k][1]-a[i][1])*(a[j][0]-a[i][0]))
                    {
                        flag=true;
                    }
                }
            }
        }
        if(flag)
            cout<<"Yes"<<endl;
        else
            cout<<"No"<<endl;
    }
}


#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <tuple>
#include <cstdio>
#include <cmath>
#define rep(i, n) for(i = 0; i < n; i++)
#define int long long
using namespace std;

int n;
int x[200000], y[200000];

signed main() {
	int i;
	
	cin >> n;
	rep(i, n) cin >> x[i] >> y[i];
	
	int xl = x[0], xr = x[0], yl = y[0], yr = y[0];
	int xlc = 0, xrc = 0, ylc = 0, yrc = 0;
	rep(i, n) xl = min(xl, x[i]);
	rep(i, n) xr = max(xr, x[i]);
	rep(i, n) yl = min(yl, y[i]);
	rep(i, n) yr = max(yr, y[i]);
	
	rep(i, n) if (xl == x[i]) xlc++;
	rep(i, n) if (xr == x[i]) xrc++;
	rep(i, n) if (yl == y[i]) ylc++;
	rep(i, n) if (yr == y[i]) yrc++;
	
	int cnt = 0;
	rep(i, n) {
		if (xl == x[i] && yl == y[i]) continue;
		if (xr == x[i] && yr == y[i]) continue;
		if (xl == x[i] || yl == y[i] || xr == x[i] || yr == y[i]) cnt++;
	}
	
	int ans = 0;
	if (xlc * xrc >= 2) ans = max(ans, xr - xl);
	if (ylc * yrc >= 2) ans = max(ans, yr - yl);
	if (cnt > 0) ans = max(ans, min(xr - xl, yr - yl));
	
	rep(i, n) if (x[i] != xr) ans = max(ans, x[i] - xl);
	rep(i, n) if (x[i] != xl) ans = max(ans, xr - x[i]);
	rep(i, n) if (y[i] != yr) ans = max(ans, y[i] - yl);
	rep(i, n) if (y[i] != yl) ans = max(ans, yr - y[i]);
	
	cout << ans << endl;
	return 0;
}