import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
public class SolClass {
	public class Point{
		public double x;
		public double y;
		public Point(double x, double y) {
			super();
			this.x = x;
			this.y = y;
		}
		
	}
private HashMap<Double, Integer> hashMap;
    
	public int maxPoints(ArrayList<Double> A, ArrayList<Double> B) {
		Double key=0.0;
	    hashMap = new HashMap<>();
	    
	    if (A == null || B == null)
	        return -1;
	    
	    if (A.size() == 0)
	        return 0;
	    
	    int n = A.size();
	    Double x1;
		Double y1;
		Double x2;
		Double y2;
	    int val;
	    int max = 0;
	    
	    for (int i = 0; i < n; i++) {
	        
	        x1 = A.get(i);
	        y1 = B.get(i);
	        hashMap.clear();
	        
	        for (int j = 0; j < n; j++) {
	            
	            if (i == j)
	                continue;
	            
	            x2 = A.get(j);
	            y2 = B.get(j);
	            
	            double slope = y2 - y1;
	            double den = x2 - x1;
	            
	            if (den == 0)
	                slope = Double.POSITIVE_INFINITY;
	            else
    	            slope = slope / den;
	            
	            val = 1;
	            
	            if (hashMap.containsKey(slope)) {
	                val = hashMap.get(slope) + 1;
	                //System.out.println("( "+x2+","+y2+" )"+"  "+slope);
	            }
	            
	            hashMap.put(slope, val);
	            
	        }
	        
	        for (Map.Entry<Double, Integer> entry : hashMap.entrySet()) {
    	        val = entry.getValue();
    	        max = Math.max(max, val);
    	        int a=0;
    	        
    	        if(a<val){
    	        	val=a;
    	        	key=entry.getKey();    	        	
    	        }
	        }	        
	    }
	    System.out.println(key);
	    
	    return max + 1;
	}
	public HashSet<Point> myAlgo(ArrayList<Double> x,ArrayList<Double> y){
		Point[] pp=new Point[x.size()];
		//HashMap<Integer, Point> in=new HashMap<>();
		for(int i=0;i<x.size();i++){
			pp[i]=new Point(x.get(i), y.get(i));
			//in.put(i, new Point(x.get(i), y.get(i)));
			
		}
		
		HashMap<Point,HashSet<Point>> aa=new HashMap<>();
		//HashMap<Double,HashSet<Point>> hh=new HashMap<Double,HashSet<Point>>();
		int maxLength=0;
		HashSet<Point> ans=new HashSet<Point>();
		for(int i=0;i<x.size()-1;i++){
			HashMap<Double,HashSet<Point>> hh=new HashMap<Double,HashSet<Point>>();
			//HashSet<Point> ans=new HashSet<Point>();
			for(int j=i+1;j<x.size();j++){
				Double slope;
				// Handing tan(pi/2) condition
				if(pp[j].x-pp[i].x==0.0){
					slope=Double.MAX_VALUE;
				}else{
					slope=(pp[j].y-pp[i].y)/(pp[j].x-pp[i].x);
				}
				if(pp[j].y-pp[i].y==0){
					slope=0.0;
				}
				if(hh.containsKey(slope)){
					HashSet<Point> set=hh.get(slope);
					set.add(pp[i]);
					set.add(pp[j]);
					/*if(slope.equals(1.0)){
					System.out.println("( "+pp[i].x+","+pp[i].y+" ) "+"( "+pp[j].x+","+pp[j].y+" ) ");
					}*/
					if(set.size()>maxLength){						
						maxLength=set.size();
						ans=set;
					}
					hh.replace(slope, set);					
				}else{
					HashSet<Point> set=new HashSet<Point>();
					set.add(pp[i]);
					set.add(pp[j]);
					if(set.size()>maxLength){						
						maxLength=set.size();
						ans=set;
					}
					/*if(slope.equals(1.0)){
						System.out.println("( "+pp[i].x+","+pp[i].y+" ) "+"( "+pp[j].x+","+pp[j].y+" ) ");
						}*/
					hh.put(slope,set);
					if(maxLength<2){
						maxLength =2;
					}
				}
				
			}
			
		}
		if(maxLength==0){
			HashSet<Point> ab=new HashSet<>();
			ab.add(pp[0]);
			return ab;
		}
		return ans;
	}
	
	public static void main(String[] args) throws IOException{		
		FileReader ff=new FileReader("./src/abc.txt");
		//BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		BufferedReader br=new BufferedReader(ff);
		String i;
		int c=0;
		int len=Integer.parseInt(br.readLine());
		Double[] a=new Double[len];
		Double[] b=new Double[len];
		while((i=br.readLine())!=null){
			String[] j=i.split(" ");			
			a[c]=Double.parseDouble(j[0]);
			b[c]=Double.parseDouble(j[1]);
			c++;			
		}		
		/*for(Double ij :a){
		 System.out.println(ij);
		 }
		System.out.println("end of x");
		System.out.println();
		for(Double ij :b){
			 System.out.println(ij);
			 }*/
		SolClass sl =new SolClass();
		//Iterator ii=sl.myAlgo(a, b).iterator();
		ArrayList<Double> t1=new ArrayList<>(Arrays.asList(a));
		ArrayList<Double> t2=new ArrayList<>(Arrays.asList(b));
		 for (Iterator iterator = sl.myAlgo(t1,t2).iterator(); iterator.hasNext();) {
		        Point type = (Point) iterator.next();
		        System.out.println(type.x+" "+type.y);
		    }
		System.out.println("Answe:");
		System.out.println(sl.maxPoints(t1, t2));	
		//System.out.println(Double.MAX_VALUE);
		br.close();
	}

}