You are given n points on a plane. All the points are distinct and no three of them lie on the same line. Find the number of parallelograms with the vertices at the given points.

Input

The first line of the input contains integer n (1 ≤ n ≤ 2000) — the number of points.

Each of the next n lines contains two integers (xi, yi) (0 ≤ xi, yi ≤ 109) — the coordinates of the i-th point.

Output

Print the only integer c — the number of parallelograms with the vertices at the given points.

Example

Input

4
0 1
1 0
1 1
2 0


Output

1
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.util.HashMap;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DNumberOfParallelograms solver = new DNumberOfParallelograms();
        solver.solve(1, in, out);
        out.close();
    }

    static class DNumberOfParallelograms {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            int n = in.scanInt();
            int points[][] = new int[n][2];
            for (int i = 0; i < n; i++) points[i] = new int[]{in.scanInt(), in.scanInt()};

            long ans = 0;
            HashMap<Long, Long> hashMap = new HashMap<>();


            for (int i = 0; i < n; i++) {
                for (int j = i + 1; j < n; j++) {
                    int xx = points[j][0] + points[i][0];
                    int yy = points[j][1] + points[i][1];
                    long h = CodeX.compute_hash(xx, yy);
                    hashMap.put(h, hashMap.getOrDefault(h, 0l) + 1);
                }
            }


            for (long dis : hashMap.keySet()) {
                long count = hashMap.get(dis);
                ans += (count * (count - 1)) / 2;
            }

            out.println(ans);


        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int INDEX;
        private BufferedInputStream in;
        private int TOTAL;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (INDEX >= TOTAL) {
                INDEX = 0;
                try {
                    TOTAL = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (TOTAL <= 0) return -1;
            }
            return buf[INDEX++];
        }

        public int scanInt() {
            int I = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    I *= 10;
                    I += n - '0';
                    n = scan();
                }
            }
            return neg * I;
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }

    static class CodeX {
        public static long compute_hash(long a, long b) {
            long temp = a * 1456973978l;
            if (temp >= 8008808808808813l) temp -= 8008808808808813l;
            long t2 = (b * 234792734l);
            if (t2 >= 8008808808808813l) t2 -= 8008808808808813l;
            temp = temp + t2;
            if (temp >= 8008808808808813l) temp -= 8008808808808813l;
            return temp;
        }

    }
}

