#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <math.h>
using namespace std ;
int gcd(int a, int b) {
   if (b < a)
      return gcd(b, a) ;
   if (a == 0)
      return b ;
   return gcd(b % a, a) ;
}
struct line {
   line(int a_, int b_, long long c_) : a(a_), b(b_), c(c_) {
      if (a < 0 || (a == 0 && b < 0)) {
         a = -a ;
         b = -b ;
         c = -c ;
      }
   }
   int a, b ;
   long long c ;
   bool on(long long x, long long y) {
      return a*x + b*y == c ;
   }
   bool operator<(const line &line2) const {
      if (a != line2.a) return a < line2.a ;
      if (b != line2.b) return b < line2.b ;
      return c < line2.c ;
   }
   bool operator==(const line &line2) const {
      return a==line2.a && b==line2.b && c==line2.c ;
   }
} ;
struct lineinfo {
   lineinfo() : bisect(0), through(0), hasincident(0) {}
   int bisect, through, hasincident ;
   int score() {
      if (through)
         return 2 * bisect + 1 + (int)floor(sqrt(2*through)) ;
      else
         return 2 * bisect ;
   }
   int upside() {
      return through == 0 ;
   }
} ;
long long dist(long long x1, long long y1, long long x2, long long y2) {
   x1 -= x2 ;
   y1 -= y2 ;
   return x1 * x1 + y1 * y1 ;
}
int main(int argc, char *argv[]) {
   int n ;
   cin >> n ;
   vector<int> xs, ys ;
   map<line, lineinfo> lines ;
   for (int i=0; i<n; i++) {
      int x, y ;
      cin >> x >> y ;
      for (int j=0; j<xs.size(); j++) {
         long long dx = x - xs[j] ;
         long long dy = y - ys[j] ;
         int g = gcd(abs(dx), abs(dy)) ;
         dx /= g ;
         dy /= g ;
         line through(dy, -dx, dy*x-dx*y) ;
         if (lines.find(through) == lines.end())
            lines[through] = lineinfo() ;
         lines[through].through++ ;
         long long mid = dx * (x + xs[j]) + dy * (y + ys[j]) ;
         if (mid % 2 == 0)
            mid /= 2 ;
         else {
            dx *= 2 ;
            dy *= 2 ;
         }
         line bisect(dx, dy, mid) ;
         if (lines.find(bisect) == lines.end())
            lines[bisect] = lineinfo() ;
         lines[bisect].bisect++ ;
      }
      xs.push_back(x) ;
      ys.push_back(y) ;
   }
   int best = 0 ;
   int maybebetter = 0 ;
   for (map<line, lineinfo>::iterator it = lines.begin();
                                               it != lines.end(); it++) {
      lineinfo &li = it->second ;
      int t = li.score() ;
      if (t > best) {
         best = t ;
         maybebetter = li.upside() ;
      } else if (t == best && li.upside())
         maybebetter = 1 ;
   }
   /* let's take a break and look at rotational symmetry */
   map<pair<int, int>, int> pts ;
   for (int i=0; i<n; i++) {
      pts[make_pair(xs[i]*2, ys[i]*2)]++ ;
      for (int j=i+1; j<n; j++)
         pts[make_pair(xs[i]+xs[j], ys[i]+ys[j])] += 2 ;
   }
   for (map<pair<int, int>, int>::iterator it = pts.begin();
                                                  it != pts.end(); it++)
      if (it->second > best) {
         best = it->second ;
         maybebetter = 0 ;
      }
   /* maybe we can do better.  Scan for better bisectors. */
   vector<pair<long long, int> > dists ;
   int foundbetter = 0 ;
   for (int i=0; foundbetter == 0 && i<xs.size(); i++) {
      int x = xs[i] ;
      int y = ys[i] ;
      dists.clear() ;
      for (int j=0; j<xs.size(); j++)
         if (i != j)
            dists.push_back(make_pair(dist(x, y, xs[j], ys[j]), j)) ;
      sort(dists.begin(), dists.end()) ;
      for (int j=0; foundbetter == 0 && j<dists.size(); ) {
         int k = j + 1 ;
         for (; k<dists.size() && dists[j].first == dists[k].first; k++) {
            long long dx = xs[dists[k].second] - xs[dists[j].second] ;
            long long dy = ys[dists[k].second] - ys[dists[j].second] ;
            int g = gcd(abs(dx), abs(dy)) ;
            dx /= g ;
            dy /= g ;
            long long mid = dx * (xs[dists[k].second] + xs[dists[j].second]) +
                            dy * (ys[dists[k].second] + ys[dists[j].second]) ;
            if (mid % 2 == 0)
               mid /= 2 ;
            else {
               dx *= 2 ;
               dy *= 2 ;
            }
            line bisect(dx, dy, mid) ;
            lineinfo li = lines[bisect] ;
            if (li.score() == best && li.upside())
               foundbetter++ ;
         }
         j = k ;
      }
   }
   if (foundbetter)
      best++ ;
   // handle base cases
   if (xs.size() <= 2)
      best = xs.size() ;
   cout << (xs.size() - best) << endl ;
}