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];

                if (i != j) {
                    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])) {
                        if (!points[i][j].equals(new Point(0, 0))) {
                            moreOccurs.add(points[i][j]);
                        }
                    }
                }
            }
        }
        addInverseVectors(moreOccurs);
        if (moreOccurs.size() == 0) {
            System.out.println("0");
            return;
        }

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

        Point currentPoint;
        Point currentVector;
        Point 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 (original.contains(nextPoint)) {
                    original.get(original.lastIndexOf(nextPoint)).isMirror = true;
                    currentPoint.visited = true;
                }
            }

            if (allVisitedOrMirror(original)) {
                posibilites++;
            }

            original.forEach(point -> {
                point.isMirror = false;
                point.visited = false;
            });
        }

        System.out.println(posibilites);
    }

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

    private static boolean allVisitedOrMirror(ArrayList<Point> original) {
        for (Point point:
             original) {
            if (point.isMirror != true && point.visited != true) {
                return false;
            }
        }
        return true;
    }

    static class Point {
        public int x;
        public int y;
        public boolean isMirror = false;
        public boolean visited = false;
        public Point(int x, int y) { this.x = x; this.y = y; }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            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 "";
        }

    }

}