import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Objects;

public class Vision {
    public static void main(String[] args) {
        BufferedReader br;
        String line = "";
        Point[][] points = null;
        int pointCount = 0;
        boolean first = true;
        String[] tokens;
        int k = 1;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            while ((line = br.readLine()) != null) {
                if (first) {
                    pointCount = Integer.parseInt(line);
                    points = new Point[pointCount + 1][pointCount + 1];
                    first = false;
                }
                else {
                    tokens = line.split("\\s");
                    Point toInsert =  new Point(Integer.parseInt(tokens[0]), Integer.parseInt(tokens[1]));
                    points[0][k] = toInsert;
                    points[k][0] = toInsert;
                    k++;
                }
            }
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }

        Point zeroJ, Izero;
        for (int i = 1; i < points.length; i++) {
            for (int j = 1; j < points[0].length; j++) {
                zeroJ = points[0][j];
                Izero = points[i][0];
                points[i][j] = new Point(zeroJ.x - Izero.x, zeroJ.y - Izero.y);
            }
        }

        ArrayList<Point> moreOccurs = new ArrayList<>();
        HashSet<Point> hashPoints = new HashSet<>();
        for (int i = 1; i < points.length; i++) {
            for (int j = 1; j < i; j++) {
                if (!hashPoints.contains(points[i][j])) {
                    hashPoints.add(points[i][j]);
                }
                else {
                    if (!moreOccurs.contains(points[i][j])) {
                        moreOccurs.add(points[i][j]);
                    }
                }
            }
        }

        if (moreOccurs.size() == 0) {
            System.out.println("0");
            return;
        }

        addInverseVectors(moreOccurs, moreOccurs.size());


        int minX = Integer.MAX_VALUE;
        int maxX = Integer.MIN_VALUE;
        int minY = Integer.MAX_VALUE;
        int maxY = Integer.MIN_VALUE;

        ArrayList<Point> original = new ArrayList<>();
        Point cur;
        for (int j = 1; j < points.length; j++) {
            cur = points[0][j];
            original.add(cur);

            if (cur.x > maxX) {
                maxX = cur.x;
            }
            if (cur.y > maxY) {
                maxY = cur.y;
            }
            if (cur.x < minX) {
                minX = cur.x;
            }
            if (cur.y < minY) {
                minY = cur.y;
            }
        }

        Point currentPoint, currentVector, nextPoint;
        int posibilites = 0;
        for (int i = 0; i < moreOccurs.size(); i++) {
            currentVector = moreOccurs.get(i);
            for (int j = 0; j < original.size(); j++) {
                currentPoint = original.get(j);
                nextPoint = new Point(currentPoint.x + currentVector.x, currentPoint.y + currentVector.y);
                if (nextPoint.x > maxX || nextPoint.x < minX || nextPoint.y > maxY || nextPoint.y < minY) {
                    continue;
                }

                if (original.contains(nextPoint)) {
                    original.get(original.lastIndexOf(nextPoint)).isMirror = true;
                    currentPoint.isMirror = true;
                }
            }
            if (allVisitedOrMirror(original)) {
                posibilites++;
            }
            for (int m = 0; m < original.size(); m++) {
                original.get(m).isMirror = false;
            }

        }

        System.out.println(posibilites);
    }

    private static void addInverseVectors(ArrayList<Point> original, int size) {
        for (int i = 0; i < size; i++) {
            original.add(new Point(- original.get(i).x, - original.get(i).y));
        }
    }

    private static boolean allVisitedOrMirror(ArrayList<Point> original) {
        Point cur;
        for (int i = 0; i < original.size(); i++) {
            cur = original.get(i);
            if (cur.isMirror != true) {
                return false;
            }
        }
        return true;
    }

    static class Point {
        public int x;
        public int y;
        public boolean isMirror = false;
        public Point(int x, int y) { this.x = x; this.y = y; }
        @Override
        public boolean equals(Object o) {
            Point point = (Point) o;
            return x == point.x &&
                    y == point.y;
        }

        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }

        @Override
        public String toString() {
            return "";
        }

    }

}