// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <cmath>

#include <vector>

#include <algorithm>

#include <stack>

#include <cstring>

#include <queue>

#include <set>



using namespace std;



const int maxN = 110;



#define FORU(i, l, r) for (int i = l; i <= r; ++i)

#define FORD(i, r, l) for (int i = r; i >= l; --i)

#define REPU(i, r) for (int i = 0; i < r; ++i)

#define F first

#define S second

#define PB push_back

#define LL long long

#define BIT(x, i) ((x >> i) & 1)



int res, m, x[maxN], y[maxN];

vector < int > idx1, idx2, idx;

set < int > mset;



double get_slope(int i, int j) {

    return (x[i] == x[j] ? -1 : (1.0 * (y[i] - y[j])) / (x[i] - x[j]));

}



int cmp_slope(int i, int j) {

    if (x[idx1[i]] == x[idx2[i]] &&

        x[idx1[j]] == x[idx2[j]]) return 0;

    if (x[idx1[i]] == x[idx2[i]]) return -1;

    if (x[idx1[j]] == x[idx2[j]]) return 1;



    int dxi = x[idx1[i]] - x[idx2[i]], dyi = y[idx1[i]] - y[idx2[i]];

    int dxj = x[idx1[j]] - x[idx2[j]], dyj = y[idx1[j]] - y[idx2[j]];

    if (dxi < 0) dxi *= (-1), dyi *= (-1);

    if (dxj < 0) dxj *= (-1), dyj *= (-1);



    if (dyi * dxj == dyj * dxi) return 0;

    if (dyi * dxj < dyj * dxi) return -1;

    return 1;

}



bool cmp(int i, int j) {

    return (cmp_slope(i, j) == -1);

}



void solve(int t) {

    if (t > (m / 2)) {

        idx.clear();

        REPU(i, idx1.size()) idx.PB(i);

        sort(idx.begin(), idx.end(), cmp);

        int num = 0, tmp = 0;

        REPU(t, idx.size()) {

            if (t && cmp_slope(idx[t], idx[t - 1]) != 0) {

                tmp += (num * (num - 1)) / 2;

                num = 0;

            }

            ++num;

        }

        tmp += (num * (num - 1)) / 2;

        res = max(res, tmp);

        return;

    }

    vector < int > arr; arr.clear();

    for (auto i : mset) arr.PB(i);

    idx1.PB(arr[0]);

    mset.erase(arr[0]);

    FORU(i, 1, arr.size() - 1) {

        idx2.PB(arr[i]);

        mset.erase(arr[i]);

        solve(t + 1);

        mset.insert(arr[i]);

        idx2.pop_back();

    }

    mset.insert(arr[0]);

    idx1.pop_back();

}



int main() {

    cin >> m;

    FORU(i, 1, m) {

        cin >> x[i] >> y[i];

        mset.insert(i);

    }

    solve(1);

    cout << res << endl;

}




// Optimized solution to the same problem (faster):
#include <cstdio>

#define LL long long

using namespace std;

int m,cnt;

int ans;

struct poi{

	int x,y;

	poi(){}

	poi(int xx,int yy){

		x=xx;

		y=yy;

	}

	void read(){

		scanf("%d%d",&x,&y);

	}

	friend poi operator-(poi a,poi b){

		return poi(a.x-b.x,a.y-b.y);

	}

	friend int operator^(poi a,poi b){

		return a.x*b.y-a.y*b.x;

	}

} p[20],s[10];

bool flag[20];

void work(){

	int fst=0;

	for (fst=1;fst<=m;fst++) if (flag[fst]==0){

		flag[fst]=1;

		break;

	}

	if (fst>m){

		int res=0;

		for (int i=1;i<=m/2;i++) for (int j=i+1;j<=m/2;j++){

			if ((s[i]^s[j])==0) res++;

			if (res>ans) ans=res;

		}

		return;

	}

	for (int i=fst+1;i<=m;i++) if (!flag[i]){

		s[++cnt]=p[i]-p[fst];

		flag[i]=1;

		work();

		flag[i]=0;

		cnt--;

	}

	flag[fst]=0;

}

int main(){

	scanf("%d",&m);

	for (int i=1;i<=m;i++) p[i].read();

	work();

	printf("%d\n",ans);

	return 0;

}


// Fastest known solution for this problem: