import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
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;
        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 {
                    Point toInsert =  new Point(Integer.parseInt(line.split("\\s")[0]), Integer.parseInt(line.split("\\s")[1]));
                    points[0][k] = toInsert;
                    points[k][0] = toInsert;
                    k++;
                }
            }
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }


        for (int i = 1; i < points.length; i++) {
            for (int j = 1; j < points[0].length; j++) {
                if (i != j) {
                    points[i][j] = new Point(points[0][j].x - points[i][0].x, points[0][j].y - points[i][0].y);
                }
                else {
                    points[i][j] = new Point(0, 0);
                }
            }
        }
        // Ted mame vsechny vzajemne vektory
        //printArray(points);
        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);
        //System.out.println(Arrays.toString(moreOccurs.toArray()));

        if (moreOccurs.size() == 0) {
            System.out.println("0");
            return;
        }
        // Markovani bodu jako mirror / visited

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

       // System.out.println("Original: " + Arrays.toString(original.toArray()));

        Point currentPoint;
        Point currentVector;
        Point nextPoint;
        int possibilites = 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);

                // Zkus na nej aplikovat kazdy z moreOccurs pokud neni obraz
                //if (!currentPoint.isMirror ) {
                    nextPoint = new Point(currentPoint.x + currentVector.x, currentPoint.y + currentVector.y);

                    //Trefa!
                    if (original.contains(nextPoint)) {
                        //System.out.println("Trefa: z" + currentPoint+ " do " + nextPoint + " s vektorem " + currentVector);
                        original.get(original.lastIndexOf(nextPoint)).isMirror = true;
                        currentPoint.visited = true;
                    }
                //}
            }

            if (allVisitedOrMirror(original)) {
                possibilites++;
            }
            refreshPoints(original);
        }

        System.out.println(possibilites);
    }

    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.visited != true && point.isMirror != true) {
                return false;
            }
        }
        return true;
    }

    private static void refreshPoints(ArrayList<Point> original) {
        original.forEach(point -> {
            point.isMirror = false;
            point.visited = false;
        });
    }

    private static void printArray(Point[][] points) {
        for (int i = 0; i < points.length; i++) {
            for (int j = 0; j < points[0].length; j++) {
                System.out.print(points[i][j] + " ");
            }
            System.out.println();
        }
    }

    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; id = counter++; }

        private int id = 0;
        private static int counter = 0;

        @Override
        public boolean equals(Object o) {
            //System.out.println("equals call");
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Point point = (Point) o;
            return x == point.x &&
                    y == point.y
                    //isMirror == point.isMirror &&
                    //id == point.id
            ;
        }

        @Override
        public int hashCode() {
            //System.out.println("hash call");
            return Objects.hash(x, y);
        }

        @Override
        public String toString() {
            if (x < 0 && y >= 0) {
                return "[" + x + ", " + y + "]";
            }
            if (y < 0 && x >= 0) {
                return "[ " + x + "," + y + "]";
            }
            if (x < 0 && y < 0) {
                return "[" + x + "," + y + "]";
            }
            return "[ " + x + ", " + y + "]";
        }

    }

}