import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int v = 0,h = 0;
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            if (a == x) {
                v = 1;
            }else if(b == y){
                h = 1;
            } else {
                double slope = ((b - y) / (double) (a - x));
                slope = Double.parseDouble(String.format("%.5f", slope));
                hs.add(slope);
            }
        }
        System.out.println(hs.size() + v+h);

    }

}


import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            double slope = ((a - x) / (double) (b - y));

            slope = Double.parseDouble(String.format("%.5f" , slope));
            hs.add(slope);
        }
        System.out.println(hs.size());

    }

}


import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            double slope = Math.abs((a - x) / (double) (b - y));
            slope = Double.parseDouble(String.format(String.valueOf(slope), ".5f"));
            hs.add(slope);
        }
        System.out.println(hs.size());

    }

}


import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int v = 0;
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            if (a == x) {
                v = 1;
            } else {
                double slope = ((a - x) / (double) (b - y));
                slope = Double.parseDouble(String.format("%.5f", slope));
                hs.add(slope);
            }
        }
        System.out.println(hs.size() + v);

    }

}


import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            double slope = ((a - x) / (double) (b - y));
            slope = Double.parseDouble(String.format(String.valueOf(slope), ".5f"));
            hs.add(slope);
        }
        System.out.println(hs.size());

    }

}


import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int v = 0;
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            if (b == y) {
                v = 1;
            } else {
                double slope = ((a - x) / (double) (b - y));
                slope = Double.parseDouble(String.format("%.5f", slope));
                hs.add(slope);
            }
        }
        System.out.println(hs.size() + v);

    }

}


import java.awt.*;
import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader sc = new FastReader();

    public static void main(String[] args) throws IOException {
        int n = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int v = 0;
        HashSet<Double> hs = new HashSet<Double>();
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            if (a == x) {
                v = 1;
            } else {
                double slope = ((b - y) / (double) (a - x));
                slope = Double.parseDouble(String.format("%.5f", slope));
                hs.add(slope);
            }
        }
        System.out.println(hs.size() + v);

    }

}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<int[]> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            double[] MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static double[] computeMC(x0, y0, x1, y1){
        double M = (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        int[] MC = new int[2];
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<int[]> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            double[] MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static double[] computeMC(int x0,int y0,int x1,int y1){
        double M = (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        int[] MC = new int[2];
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        double M = (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>();
        MC.add(M);
        MC.add(C);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<int[]> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            double[] MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static double[] computeMC(int x0,int y0,int x1,int y1){
        double M = (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        double[] MC = new double[2];
        MC[0] = M;
        MC[1] = C;
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        double M = xdiff == 0 ? 0: ydiff/xdiff;
        double C = xdiff == 0 ? 0:(y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>();
        MC.add(M);
        MC.add(C);
        if(xdiff == 0) MC.add(1.1);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            double M = computeM(x0, y0, x1, y1);
            set.add(M);
        }

        System.out.println(set.size());
    }

    public static double computeM(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        return xdiff == 0 ? Double.MAX_VALUE : (double)ydiff/(double)xdiff;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            ArrayList<Double> MC = computeM(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static double computeMC(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        return xdiff == 0 ? Double.MAX_VALUE : ydiff/xdiff;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            double M = computeM(x0, y0, x1, y1);
            set.add(M);
        }

        System.out.println(set.size());
    }

    public static double computeM(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        return xdiff == 0 ? Double.MAX_VALUE : (double)ydiff/xdiff;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<double[]> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            double[] MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static double[] computeMC(int x0,int y0,int x1,int y1){
        double M = (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        double[] MC = new double[2];
        MC[0] = M;
        MC[1] = C;
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        int xdiff = x1-x0;
        double M = xdiff == 0 ? 0: (y1-y0)/(x1-x0);
        double C = xdiff == 0 ? 0:(y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>();
        MC.add(M);
        MC.add(C);
        if(xdiff == 0) MC.add(1.1);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            double M = computeM(x0, y0, x1, y1);
            set.add(M);
        }

        System.out.println(set.size());
    }

    public static double computeMC(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        return xdiff == 0 ? Double.MAX_VALUE : ydiff/xdiff;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        double M = xdiff == 0 ? 0: ydiff/xdiff;
        double C = xdiff == 0 ? 0:(y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>();
        MC.add(M);
        MC.add(C);
        if(xdiff == 0) MC.add(1.1);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        int xdiff = x1-x0;
        double M = xdiff == 0 ? 0: (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>();
        MC.add(M);
        MC.add(C);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            double M = computeM(x0, y0, x1, y1);
            set.add(M);
        }

        System.out.println(set.size());
    }

    public static double computeM(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        return xdiff == 0 ? Double.MAX_VALUE : ydiff/xdiff;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            double M = computeM(x0, y0, x1, y1);
            set.add(M);
        }

        System.out.println(set.size());
    }

    public static double computeM(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        return xdiff == 0 ? Double.MAX_VALUE : (double)(ydiff/xdiff);
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        int xdiff = x1-x0;
        double M = xdiff == 0 ? 0: (y1-y0)/(x1-x0);
        double C = xdiff == 0 ? 0:(y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>();
        MC.add(M);
        MC.add(C);
        if(xdiff == 0) MC.add(1);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<ArrayList<Double>> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            ArrayList<Double> MC = computeMC(x0, y0, x1, y1);
            set.add(MC);
        }

        System.out.println(set.size());
    }

    public static ArrayList<Double> computeMC(int x0,int y0,int x1,int y1){
        double M = (y1-y0)/(x1-x0);
        double C = (y0)-M*x0;
        ArrayList<Double> MC = new ArrayList<>;
        MC.add(M);
        MC.add(C);
        return MC;
    }
}


import java.util.*;

public final class Solution{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int x0 = s.nextInt();
        int y0 = s.nextInt();
        HashSet<Double> set = new HashSet<>();
        while(s.hasNextInt()){
            int x1 = s.nextInt();
            int y1 = s.nextInt();
            if(x1 == x0 && y1 == y0) continue;
            double M = computeM(x0, y0, x1, y1);
            set.add(M);
        }

        System.out.println(set.size());
    }

    public static double computeM(int x0,int y0,int x1,int y1){
        double xdiff = x1-x0;
        double ydiff = y1-y0;
        if(ydiff == 0) return 0.0;
        return xdiff == 0 ? Double.MAX_VALUE : (double)(ydiff/xdiff);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int gcd(int a, int b) {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int ans = 0;
        Set<List<Integer>> set = new HashSet();
        out.println(gcd(0,5));
        out.println(gcd(5,0));
        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            int dx = (x - x0);
            int dy = (y - y0);
            int g = gcd((int)Math.abs(dx), (int)Math.abs(dy));
            if(dx == 0) {
                dy = 1;
            }else if(dy == 0) {
                dx = 1;
            }else {
                if(dy < 0) g = -g;
                dx /= g; dy /= g;
            }
            List <Integer> l = new ArrayList();
            l.add(dx);
            l.add(dy);
            set.add(l);
        }

        out.println(set.size());
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);

    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int ans = 0;
        HashMap<Double, Integer> map = new HashMap();
        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            double slope = 1e9;
            if(x0 != x) {
                slope = (double)(y - y0)/(double)(x - x0);
            }
            if(!map.containsKey(slope)) {
                map.put(slope, 1);
            }
        }
        for(double key : map.keySet()) {
            ans += map.get(key);
        }
        out.println(ans);
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int gcd(int a, int b) {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    void solve() {
        int n = ir.readInt();
        int x1 = ir.readInt();
        int y1 = ir.readInt();
        int ans = 0;
        Set<List<Integer>> set = new HashSet();
        int x[] = new int[n];
        int y[] = new int[n];
        boolean visit[] = new boolean[n];
        for(int i = 0; i < n; i++) {
            x[i] = ir.readInt();
            y[i] = ir.readInt();
        }

        for(int i = 0; i < n; i++) {
            if(visit[i])
                continue;
            ans++;
            visit[i] = true;
            for(int j = 0; j < n; j++) {
                if(visit[j])
                    continue;
                int l = (y[j] - y1)*(x[i] - x[j]);
                int r = (y[i] - y[j])*(x[j] - x1);
                if(l == r) {
                    visit[j] = true;

                }
            }
        }

        out.println(ans);
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int gcd(int a, int b) {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int ans = 0;
        Set<List<Integer>> set = new HashSet();
        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            int dx = (x - x0);
            int dy = (y - y0);
            int g = gcd(dx, dy);
            dx /= g;
            dy /= g;
            List <Integer> l = new ArrayList();
            l.add(dx);
            l.add(dy);
            Collections.sort(l);
            set.add(l);
        }

        out.println(set.size());
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int gcd(int a, int b) {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int ans = 0;
        Set<List<Integer>> set = new HashSet();
        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            int dx = (x - x0);
            int dy = (y - y0);
            int g = gcd((int)Math.abs(dx), (int)Math.abs(dy));
            if(dy < 0)
                g = -g;
            dx /= g;
            dy /= g;
            List <Integer> l = new ArrayList();
            l.add(dx);
            l.add(dy);
            set.add(l);
        }

        out.println(set.size());
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int gcd(int a, int b) {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int ans = 0;
        Set<List<Integer>> set = new HashSet();

        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            int dx = (x - x0);
            int dy = (y - y0);
            int g = gcd((int)Math.abs(dx), (int)Math.abs(dy));
            if(dx == 0) {
                dy = 1;
            }else if(dy == 0) {
                dx = 1;
            }else {
                if(dy < 0) g = -g;
                dx /= g; dy /= g;
            }
            List <Integer> l = new ArrayList();
            l.add(dx);
            l.add(dy);
            set.add(l);
        }

        out.println(set.size());
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);

    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int h = 0;
        int v = 0;
        int d1 = 0;
        int d2 = 0;
        int ans = 0;
        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            double slope = 1e10;
            if(x0 - x != 0)
            slope = (double)(y0 - y)/(double)(x0 - x);

            if(x == x0) {
                v = 1;
            } else if(y == y0) {
                h = 1;
            } else if(slope == 1.0) {
                d1 = 1;
            } else if(slope == -1.0) {
                d2 = 1;
            } else {
                ans++;
            }
        }
        out.println(ans + h + v + d1 + d2);
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
@SuppressWarnings("unchecked")
public class Main {
    InputReader ir = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);

    void solve() {
        int n = ir.readInt();
        int x = ir.readInt();
        int y = ir.readInt();
        int ans = 0;
        HashSet<Double> set = new HashSet();
        while(n-- > 0) {
            int x0 = ir.readInt();
            int y0 = ir.readInt();
            double slope = 1e9;
            if(x0 != x)
                slope = (double)(x - x0)/(double)(y - y0);
            set.add(slope);
        }

        out.println(set.size());
    }
    void run() {
        solve();
        out.close();
    }
    public static void main(String args[]){
        new Main().run();
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    public final int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
    }
    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
        public double readDouble() {
        return Double.parseDouble(readString());
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}
class ArrayUtil {
    static int lowerbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] <= key) {
                return lowerbs(arr, mid, end, key);
            } else {
                return lowerbs(arr, start, mid - 1, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] <= key) {
                    idx = i;
                }
            }
            return idx;
        }
    }
    static int upperbs(int arr[], int start, int end, int key) {
        if(start + 1 < end) {
            int mid = start + (end - start)/2;
            if(arr[mid] >= key) {
                return upperbs(arr, start, mid, key);
            } else {
                return upperbs(arr, mid + 1, end, key);
            }
        } else {
            int idx = -1;
            for(int i = start; i <= end; i++) {
                if(arr[i] >= key) {
                    idx = i;
                    break;
                }
            }
            return idx;
        }
    }
}
class Pair <Type1 extends Comparable<Type1>, Type2 extends Comparable<Type2>> implements Comparable <Pair<Type1, Type2>>{
    Type1 first;
    Type2 second;
    public Pair(Type1 F, Type2 S) {
        this.first = F;
        this.second = S;
    }
    @Override
    public int compareTo(Pair <Type1, Type2> p) {
        if(first.compareTo(p.first) == 0)
            return second.compareTo(p.second);
        return first.compareTo(p.first);
    }
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		int myX = scan.nextInt();
		int myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		int infFlag = 0;
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			if(tX - myX == 0) {
				infFlag = 1;
			}
			else {
				double thisSlope = (tY - (double)myY)/(tX - (double)myX);
				mySlopes.add(thisSlope);
				numTroopers --;
			}
		}
		System.out.println(mySlopes.size() + infFlag);
	}
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		double myX = scan.nextInt();
		double myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		int infFlag = 0;
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			if(tX == myX) {
				infFlag = 1;
			}
			else {
				double thisSlope = (tY - myY)/(tX - myX);
				mySlopes.add(thisSlope);
			}
			numTroopers --;
		}
		System.out.println(mySlopes.size() + infFlag);
	}
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		int myX = scan.nextInt();
		int myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		int infFlag = 0;
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			if(tX - myX == 0) {
				infFlag = 1;
			}
			else {
				double thisSlope = (tY - (double)myY)/(tX - (double)myX);
				mySlopes.add(thisSlope);
			}
			numTroopers --;
		}
		System.out.println(mySlopes.size());
	}
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		int myX = scan.nextInt();
		int myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		int infFlag = 0;
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			if(tX - myX == 0) {
				infFlag = 1;
			}
			else {
				double thisSlope = (tY - (double)myY)/(tX - (double)myX);
				mySlopes.add(thisSlope);
			}
			numTroopers --;
		}
		System.out.println(mySlopes.size() + infFlag);
	}
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		double myX = scan.nextInt();
		double myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		int infFlag = 0;
		int zFlag = 0;
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			if(tX == myX) {
				infFlag = 1;
			}
			else if(tY == myY) {
				zFlag = 1;
			}
			else {
				double thisSlope = (tY - myY)/(tX - myX);
				mySlopes.add(thisSlope);
			}
			numTroopers --;
		}
		System.out.println(mySlopes.size() + infFlag + zFlag);
	}
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		double myX = scan.nextInt();
		double myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		int infFlag = 0;
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			if(tX == yX) {
				infFlag = 1;
			}
			else {
				double thisSlope = (tY - myY)/(tX - myX);
				mySlopes.add(thisSlope);
			}
			numTroopers --;
		}
		System.out.println(mySlopes.size() + infFlag);
	}
}


import java.util.*;
import java.io.*;

public class CF9 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int numTroopers = scan.nextInt();
		int myX = scan.nextInt();
		int myY = scan.nextInt();
		HashSet<Double> mySlopes = new HashSet<Double>();
		while(numTroopers > 0) {
			double tX = scan.nextInt();
			double tY = scan.nextInt();
			double thisSlope = (tY - (double)myY)/(tX - (double)myX);
			mySlopes.add(thisSlope);
			numTroopers --;
		}
		System.out.println(mySlopes.size());
	}
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        boolean isVert = false;
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	double x = scan.nextInt();
        	double y = scan.nextInt();
        	if (x - hanX == 0) {
        		isVert = true;
        	}
        	else {
        		double slope = (y - hanY) / (x - hanX);
        		slopes.add(slope);
        	}
        }
        scan.close();
        int size = isVert ? slopes.size() + 1 : slopes.size();
        System.out.println(size);
    }
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	int x = scan.nextInt();
        	int y = scan.nextInt();
        	double slope = (y - hanY) / (x - hanX);
        	slopes.add(Math.abs(slope));
        }
        scan.close();
        System.out.println(slopes.size());
    }
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	int x = scan.nextInt();
        	int y = scan.nextInt();
        	double slope = (y - hanY) / (x - hanX);
        	slopes.add(slope);
        }
        scan.close();
        System.out.println(slopes.size());
    }
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        boolean isVert = false;
        double scale = Math.pow(10, 6);
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	double x = scan.nextInt();
        	double y = scan.nextInt();
        	if (x - hanX == 0) {
        		isVert = true;
        	}
        	else {
        		double slope = (y - hanY) / (x - hanX);
        		slopes.add(Math.round(slope * scale) / scale);
        	}
        }
        scan.close();
        int size = isVert ? slopes.size() + 1 : slopes.size();
        System.out.println(size);
    }
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        boolean isVert = false;
        double scale = Math.pow(10, 20);
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	double x = scan.nextInt();
        	double y = scan.nextInt();
        	if (x - hanX == 0) {
        		isVert = true;
        	}
        	else {
        		double slope = (y - hanY) / (x - hanX);
        		slopes.add(Math.round(slope * scale) / scale);
        	}
        }
        scan.close();
        int size = isVert ? slopes.size() + 1 : slopes.size();
        System.out.println(size);
    }
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	double x = scan.nextInt();
        	double y = scan.nextInt();
        	double slope = (y - hanY) / (x - hanX);
        	slopes.add(slope);
        }
        scan.close();
        System.out.println(slopes.size());
    }
}


import java.util.*;

public class codeforces9 {

    public static void main (String[] args) {
        Scanner scan = new Scanner(System.in);
        int numTroopers = scan.nextInt();
        double hanX = scan.nextInt();
        double hanY = scan.nextInt();
        boolean isVert = false;
        double scale = Math.pow(10, 10);
        HashSet<Double> slopes = new HashSet<>();
        for (int i = 0; i < numTroopers; i++) {
        	double x = scan.nextInt();
        	double y = scan.nextInt();
        	if (x - hanX == 0) {
        		isVert = true;
        	}
        	else {
        		double slope = (y - hanY) / (x - hanX);
        		slopes.add(Math.round(slope * scale) / scale);
        	}
        }
        scan.close();
        int size = isVert ? slopes.size() + 1 : slopes.size();
        System.out.println(size);
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        int stormx = 0;
        int stormy = 0;

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextInt();
            stormy = scan.nextInt();
            int slope;
            if((stormx-lx)==0)slope=-999;
            else
                slope = (stormy - ly)/(stormx - lx);
            set.add((double) slope);
        }
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        int stormx = 0;
        int stormy = 0;

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextInt();
            stormy = scan.nextInt();
            int slope = 0;
            if((stormx-lx)==0)continue;
            else
                slope = (stormy - ly)/(stormx - lx);
                set.add((double) slope);
        }
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        double stormx = 0;
        double stormy = 0;
        LinkedList<Double> col = new LinkedList<Double>();

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextDouble();
            stormy = scan.nextDouble();
            double slope;
            if((stormx-lx)==0)slope=-999;
            else
                slope = (stormy - ly)/(stormx - lx);
            set.add((double) slope);
            col.add((double) slope);
        }
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        int stormx = 0;
        int stormy = 0;

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextInt();
            stormy = scan.nextInt();

            int slope = (stormy - ly)/(stormx - lx);
            set.add((double) slope);
        }
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        int stormx = 0;
        int stormy = 0;

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextInt();
            stormy = scan.nextInt();
            int slope = 0;
            if((stormx-lx)==0)slope =1;
            else
                slope = (stormy - ly)/(stormx - lx);
            set.add((double) slope);
        }
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        double stormx = 0;
        double stormy = 0;
        LinkedList<Double> col = new LinkedList<Double>();

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextDouble();
            stormy = scan.nextDouble();
            double slope;
            if((stormx-lx)==0)slope=-999;
            else
                slope = (stormy - ly)/(stormx - lx);
            set.add((double) slope);
            col.add((double) slope);
        }
        System.out.println(col.toString());
        System.out.println(set.toString());
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        int stormx = 0;
        int stormy = 0;

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            double x = (double)(scan.nextInt() - lx);
            double y = (double)(scan.nextInt() - ly);
            if(y==0)
                x = Math.abs(x);
            if(x==0)
                y = Math.abs(y);
            set.add(x/y);
        }
        System.out.println(set.size());
    }
}


import java.util.*;

public class han {
    public static void main(String agrs[]){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int lx = scan.nextInt();
        int ly = scan.nextInt();
        int stormx = 0;
        int stormy = 0;

        HashSet<Double> set = new HashSet<Double>();

        for (int i = 0; i<n ; i++){
            stormx = scan.nextInt();
            stormy = scan.nextInt();
            int slope = 0;
            if((stormx-lx)==0)continue;
            else{
                slope = (stormy - ly)/(stormx - lx);
                set.add((double) slope);}
        }
        System.out.println(set.size());
    }
}


import java.io.*;
import java.util.LinkedHashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        LinkedHashMap<Double, Boolean> map = new LinkedHashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * 1.000000) / (enemy.x - x0) : Integer.MAX_VALUE;
        slope = Double.parseDouble(String.format("%.2f", slope));
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.y-y0==0? 0.0 : (enemy.x - x0 != 0 ? ((enemy.y - y0) * (1.0)) / (enemy.x - x0) : Integer.MAX_VALUE);
            slope = Double.parseDouble(String.format("%.2f", slope));
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.LinkedHashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        LinkedHashMap<Double, Boolean> map = new LinkedHashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * 1.000000) / (enemy.x - x0) : Integer.MAX_VALUE;
        slope = Double.parseDouble(String.format("%.16f", slope));
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.y-y0==0? 0.0 : (enemy.x - x0 != 0 ? ((enemy.y - y0) * (1.0)) / (enemy.x - x0) : Integer.MAX_VALUE);
            slope = Double.parseDouble(String.format("%.16f", slope));
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.LinkedHashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        LinkedHashMap<Double, Boolean> map = new LinkedHashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * 1.000000) / (enemy.x - x0) : Integer.MAX_VALUE;
        slope = Double.parseDouble(String.format("%.2f", slope));
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.y-y0==0? 0.0 : (enemy.x - x0 != 0 ? ((enemy.y - y0) * (1.0)) / (enemy.x - x0) : Integer.MAX_VALUE);
            slope = Double.parseDouble(String.format("%.10f", slope));
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        HashMap<Double, Boolean> map = new HashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * 1.000000) / (enemy.x - x0) : Integer.MAX_VALUE;
        slope = Double.parseDouble(String.format("%.2f", slope));
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * (1.0)) / (enemy.x - x0) : Integer.MAX_VALUE;
            slope = Double.parseDouble(String.format("%.2f", slope));
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.LinkedHashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        LinkedHashMap<Double, Boolean> map = new LinkedHashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * 1.000000) / (enemy.x - x0) : Integer.MAX_VALUE;
        slope = Double.parseDouble(String.format("%.2f", slope));
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.y-y0==0? 0.0 : (enemy.x - x0 != 0 ? ((enemy.y - y0) * (1.0)) / (enemy.x - x0) : Integer.MAX_VALUE);
            slope = Double.parseDouble(String.format("%.16f", slope));
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        HashMap<Double, Boolean> map = new HashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x-x0!=0 ? ((enemy.y - y0)*1.0) / (enemy.x - x0) : Integer.MAX_VALUE;
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.x-x0!=0 ? ((enemy.y - y0)*(1.0)) / (enemy.x - x0) : Integer.MAX_VALUE;
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.LinkedHashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        LinkedHashMap<Double, Boolean> map = new LinkedHashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        double slope = enemy.x - x0 != 0 ? ((enemy.y - y0) * 1.000000) / (enemy.x - x0) : Integer.MAX_VALUE;
        slope = Double.parseDouble(String.format("%.2f", slope));
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.y-y0==0? 0.0 : (enemy.x - x0 != 0 ? ((enemy.y - y0) * (1.0)) / (enemy.x - x0) : Integer.MAX_VALUE);
            slope = Double.parseDouble(String.format("%.6f", slope));
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        StringTokenizer st = new StringTokenizer(str, " ");
        int n = Integer.parseInt(st.nextToken());
        int x0 = Integer.parseInt(st.nextToken());
        int y0 = Integer.parseInt(st.nextToken());
        HashMap<Integer, Boolean> map = new HashMap<>();
        String s = br.readLine();
        st = new StringTokenizer(s, " ");
        StormTrooper enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
        int slope = enemy.x-x0!=0 ? (enemy.y - y0) / (enemy.x - x0) : Integer.MAX_VALUE;
        map.put(slope, true);
        for (int i = 1; i < n; i++) {
            s = br.readLine();
            st = new StringTokenizer(s, " ");
            enemy = new StormTrooper(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
            slope = enemy.x-x0!=0 ? (enemy.y - y0) / (enemy.x - x0) : Integer.MAX_VALUE;
            if (!map.containsKey(slope)) {
                map.put(slope, true);
            }
        }
        bw.write(map.size() + "\n");
        bw.flush();
    }

    public static class StormTrooper {
        int x;
        int y;

        public StormTrooper(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.util.*;
public class Stormtroopers {

	public static void main(String[] args) {
		String s = "2 1 2 1 1 1 0";
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int x = in.nextInt();
		int y = in.nextInt();
		HashSet<Double> lines = new HashSet<>();
		for(int i = 0; i < n; i++){
			int thisX = in.nextInt();
			int thisY = in.nextInt();
			double thisM;
			if(thisX - x == 0)
				thisM = Integer.MAX_VALUE;
			else
				thisM = (thisY - y)/(thisX - x);
			if(!lines.contains(thisM))
				lines.add(thisM);
		}
		in.close();
		System.out.print(lines.size());
	}
}


import java.util.*;
public class Stormtroopers {

	public static void main(String[] args) {
		//String s = "10 -4 -4 2 -4 2 0 -4 2 5 -4 -3 -5 1 4 -4 2 -3 5 0 -3 2 4";
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int x = in.nextInt();
		int y = in.nextInt();
		HashSet<Double> lines = new HashSet<>();
		for(int i = 0; i < n; i++){
			double thisX = in.nextDouble();
			double thisY = in.nextDouble();
			double thisM;
			if(thisX - x == 0)
				thisM = Integer.MAX_VALUE;
			else
				thisM = (thisY - y)/(thisX - x);
			if(!lines.contains(thisM)){
				lines.add(thisM);
			}
		}
		in.close();
		System.out.print(lines.size());
	}
}