#pragma region template
#include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
// using cpp_int = boost::multiprecision::cpp_int;
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T>
using pqrev = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for (ll i = 0, i##_end = (n); i < i##_end; i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for (ll i = (a), i##_end = (b); i < i##_end; i++)
#define reprb(i, a, b) for (ll i = (b)-1, i##_end = (a); i >= i##_end; i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
template <typename T>
constexpr T local([[maybe_unused]] const T &lcl, [[maybe_unused]] const T &oj) {
#ifdef OJ_LOCAL
  return lcl;
#else
  return oj;
#endif
}
template <typename S, typename T>
constexpr bool chmax(S &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename S, typename T>
constexpr bool chmin(S &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T>
T max(const vector<T> &x) {
  return *max_element(ALL(x));
}
template <typename T>
T min(const vector<T> &x) {
  return *min_element(ALL(x));
}
template <typename T>
pair<T, int> argmax(const vector<T> &x) {
  int idx = 0;
  T m = x[0];
  repr(i, 1, SZ(x)) {
    if (chmax(m, x[i])) idx = i;
  }
  return {m, idx};
}
template <typename T>
pair<T, int> argmin(const vector<T> &x) {
  int idx = 0;
  T m = x[0];
  repr(i, 1, SZ(x)) {
    if (chmin(m, x[i])) idx = i;
  }
  return {m, idx};
}
template <typename T>
T sum(const vector<T> &x) {
  return accumulate(ALL(x), T(0));
}
// last param -> T
template <typename T>
vector<T> makev(size_t a, T b) {
  return vector<T>(a, b);
}
template <typename... Args>
auto makev(size_t sz, Args... args) {
  return vector<decltype(makev(args...))>(sz, makev(args...));
}

template <typename T>
bool print_(const T &a) {
  cout << a;
  return true;
}
template <typename T>
bool print_(const vector<T> &vec) {
  for (auto &a : vec) {
    cout << a;
    if (&a != &vec.back()) cout << " ";
  }
  return false;
}
template <typename T>
bool print_(const vector<vector<T>> &vv) {
  for (auto &v : vv) {
    for (auto &a : v) {
      cout << a;
      if (&a != &v.back()) cout << " ";
    }
    if (&v != &vv.back()) cout << "\n";
  }
  return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&... tail) {
  bool f = print_(head);
  if (sizeof...(tail) != 0) cout << (f ? " " : "\n");
  print(forward<Tail>(tail)...);
}
#pragma endregion

//*
constexpr ll MOD = 1e9 + 7;
/*/
constexpr ll MOD = 998244353;
//*/

#define PR(f)                                                                  \
  do {                                                                         \
    cout << ((f) ? "Yes" : "No") << "\n";                                      \
    return;                                                                    \
  } while (0)

void solve() {
  ll n;
  cin >> n;
  vll x(n), y(n);
  rep(i, n){
    cin >> x[i] >> y[i];
  }
  bool f = 0;
  rep(i, n)repr(j, i+1, n)repr(k, j+1, n){
    ll a = x[i]-x[j];
    ll b = y[i]-y[j];
    ll c = x[i]-x[k];
    ll d = y[i]-y[k];
    f |= (a*d==b*c);
  }
  PR(f);
}

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(20);
  //*
  solve();
  /*/
  ll _cases;
  cin >> _cases;
  while (_cases--) solve();
  //*/
}

#include <bits/stdc++.h>
int N;
int gcd(int x, int y){
    y = abs(y);
    while (y){
        x %= y;
        std::swap(x, y);
    }
    return x;
}
bool line(int dx1, int dy1, int dx2, int dy2){
    if (dx1 == 0)
        return dx2 == 0;
    else if (dy1 == 0)
        return dy2 == 0;
    else if (dx2 == 0 or dy2 == 0)
        return false;
    else {
        int gcd1 = gcd(dx1, dy1);
        dx1 /= gcd1;
        dy1 /= gcd1;
        int gcd2 = gcd(dx2, dy2);
        dx2 /= gcd2;
        dy2 /= gcd2;
        return dx1 == dx2 and dy1 == dy2;
    }
}
int main(){
    std::cin >> N;
    std::vector<std::pair<int, int>> pos;
    for (int i = 0; i < N; ++i){
        int x, y;
        std::cin >> x >> y;
        pos.push_back(std::make_pair(x, y));
    }
    std::sort(pos.begin(), pos.end());
    // for (int i = 0; i < N; ++i){
    //     std::cout << pos[i].first << pos[i].second << std::endl;
    // }
    for (int i = 0; i < N - 2; ++i){
        int x1 = pos[i].first;
        int y1 = pos[i].second;
        for (int j = i + 1; j < N - 1; ++j){
            int x2 = pos[j].first;
            int y2 = pos[j].second;
            int dx1 = x2 - x1, dy1 = y2 - y1;
            for (int k = j + 1; k < N; ++k){
                int x3 = pos[k].first;
                int y3 = pos[k].second;
                int dx2 = x3 - x2, dy2 = y3 - y2;
                if (line(dx1, dy1, dx2, dy2)){
                    std::cout << "Yes";
                    return 0;
                }
            }
        }
    }
    std::cout << "No";
    return 0;
}