#include <bits/stdc++.h>

using namespace std;

namespace {
    /** output whole vector. ex) vector<int>{1, 2, 3} -> '1 2 3'. */
    template<typename T>
    ostream& operator<<(ostream& os, const vector<T>& xs) {
       if (xs.empty()) return os << "[]";
       os << "[" << xs[0];
       for (auto i = 1; i < xs.size(); i++) os << ' ' << xs[i];
       return os << "]";
    }

    const double EPS = 1e-8;
    struct Point {
        double x, y;
        Point() {}
        Point(double x, double y) : x(x), y(y) {}
        Point operator-() const {
            return Point(-x, -y);
        }
        Point operator-(const Point& p) const {
            return Point(x - p.x, y - p.y);
        }
        Point unit() const {
            auto d = sqrt(x*x + y*y);
            return Point(x / d, y / d);
        }
    };
    bool eq(const Point &a, const Point& b) {
        return abs(a.x - b.x) < EPS && abs(a.y - b.y) < EPS;
    }
    int M;
    vector<Point> P;
    void input() {
        cin >> M;
        P.resize(M);
        for (int i = 0; i < M; i++) {
            cin >> P[i].x >> P[i].y;
        }
    }

    const int N = 100;
    int dp[N][N];
    void init_pascal() {
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1;
        for (int i = 1; i < N; i++) {
            dp[i][0] = dp[i - 1][0];
            for (int j = 1; j <= i; j++) {
                dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]);
            }
        }
    }
    int comb(int n, int k) {
        return dp[n][k];
    }

    struct Line {
        Point a, b;
        Line(Point a, Point b) : a(a), b(b) {}
    };
    bool parallel(Line& l, Line& s) {
        auto p = l.b - l.a;
        auto q = s.b - s.a;
        return eq(p.unit(), q.unit()) || eq(-p.unit(), q.unit());
    }

    int memo[(1 << 16) + 10];
    int f(int bit) {
        auto& cache = memo[bit];
        if (cache >= 0) return cache;
        int ans = 0;
        for (int i = 0; i < M; i++) {
            if (bit & (1 << i)) continue;
            for (int j = i + 1; j < M; j++) {
                if (bit & (1 << j)) continue;
                auto l = Line(P[i], P[j]);

                vector<vector<int>> cands(M, vector<int>());
                for (int k = 0; k < M; k++) {
                    if (k == i || k == j) continue;
                    if (bit & (1 << k)) continue;
                    for (int x = k + 1; x < M; x++) {
                        if (bit & (1 << x)) continue;
                        auto s = Line(P[k], P[x]);
                        if (parallel(l, s)) {
                            cands[k].push_back(x);
                        }
                    }
                }
                //cout << "(" << i << "," << j << ")" << endl << cands << endl;

                // (k, x)??¨???????????????????????????????????????
                function<int(int, int, int)> dfs = [&](int p, int bit, int count) {
                    if (p == M) return f(bit) + comb(count + 1, 2);
                    if (bit & 1 << p) return dfs(p + 1, bit, count);
                    if (cands[p].empty()) return dfs(p + 1, bit, count);
                    int ans = comb(count + 1, 2);
                    for (auto c : cands[p]) {
                        if (bit & (1 << c)) continue;
                        auto nbit = bit | 1 << c | 1 << p;
                        ans = max(ans, dfs(p, nbit, count + 1));
                    }
                    return ans;
                };
                ans = max(ans, dfs(0, bit | 1 << i | 1 << j, 0));
            }
        }
        return cache = ans;
    }

    void solve() {
        init_pascal();
        memset(memo, -1, sizeof(memo));
        cout << f(0) << endl;
    }
}

int main() {
    input(); solve();
    return 0;
}

Measured memory_bytes: 3532