import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;

public class Vision {

    private static final int BLANK = 0;
    private static final int OPTIONAL = 1;
    private static final int HIT = 2;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int[] STAR_X = new int[N];
        int[] STAR_Y = new int[N];

        for (int i = 0; i < N; i++) {
            String parts[] = br.readLine().split(" ");
            STAR_X[i] = Integer.parseInt(parts[0]);
            STAR_Y[i] = Integer.parseInt(parts[1]);
        }

        int map[][] = new int[N][N];
        HashMap<Integer,State> vectors = new HashMap<>();

        for (int i = 0; i < N; i++) {
            for (int j = i+1; j < N; j++) {
                int DX = STAR_X[i] - STAR_X[j];
                int DY = STAR_Y[i] - STAR_Y[j];

                map[i][j] = +DX + +DY * 10000;
                map[j][i] = -DX + -DY * 10000;

                if (vectors.containsKey(map[i][j]) == false) {
                    vectors.put(map[i][j], new State(N));
                }
                vectors.get(map[i][j]).eval(i,j);

                if (vectors.containsKey(map[j][i]) == false) {
                    vectors.put(map[j][i], new State(N));
                }
                vectors.get(map[j][i]).eval(j,i);
            }
        }
        int count = 0;
        for (State state : vectors.values()) {
            if (state.ok == N) {
                count++;
            }
        }
        System.out.println(count);
    }

    private static class State {
        public int ok;
        public int[] state;

        public State(int N) {
            state = new int[N];
            ok = 0;
        }

        public void eval(int x, int y) {
            if (state[x] == BLANK) {
                ok++;
            }
            state[x] = HIT;
            if (state[y] == BLANK) {
                ok++;
                state[y] = OPTIONAL;
            }
        }
    }
}