#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
#include <experimental/iterator>
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

using lld = int64_t;

struct P3 {
  lld x, y, z;
  P3 operator+(const P3 &b) const {
    return {x+b.x, y+b.y, z+b.z};
  }
  P3 operator-(const P3 &b) const {
    return {x-b.x, y-b.y, z-b.z};
  }
  P3 operator-() const {
    return {-x, -y, -z};
  }
  bool operator==(const P3 &b) const {
    return x==b.x && y==b.y && z==b.z;
  }
  bool operator<(const P3 &b) const {
    return tuple(x, y, z) < tuple(b.x, b.y, b.z);
  }
};

P3 reduced(const P3 &p) {
  lld g = abs(gcd(gcd(p.x, p.y), p.z));
  return {p.x / g, p.y / g, p.z / g};
}

lld dot(const P3 &a, const P3 &b) {
  return a.x*b.x+a.y*b.y+a.z*b.z;
}

lld norm(const P3 &p) {
  return dot(p, p);
}

P3 cross(const P3 &a, const P3 &b) {
  return {a.y*b.z-a.z*b.y, a.z*b.x-a.x*b.z, a.x*b.y-a.y*b.x};
}
bool same_dir(const P3 &a, const P3 &b) {
  return cross(a, b) == P3(0, 0, 0) && dot(a, b) > 0;
}

struct Ray {
  P3 s, dir;
  Ray(P3 t_s, P3 t_dir) : s(t_s), dir(t_dir) {}
};

bool intersect(const Ray &a, const Ray &b) {
  if (dot(a.s - b.s, cross(a.dir, b.dir)) != 0)
    return false;

  return
    same_dir(cross(b.s - a.s, b.dir), cross(a.dir, b.dir)) &&
    same_dir(cross(a.s - b.s, a.dir), cross(b.dir, a.dir));
}

const lld INF = 1e18;
bool chmin(auto &x, auto v) {
  if (x > v) return x = v, true;
  return false;
}

struct KM { // maximize, test @ UOJ 80
  int n, l, r; lld ans; // fl and fr are the match
  vector<lld> hl, hr; vector<int> fl, fr, pre, q;
  void bfs(const auto &w, int s) {
    vector<int> vl(n), vr(n); vector<lld> slk(n, INF);
    l = r = 0; vr[q[r++] = s] = true;
    const auto check = [&](int x) -> bool {
      if (vl[x] || slk[x] > 0) return true;
      vl[x] = true; slk[x] = INF;
      if (fl[x] != -1) return (vr[q[r++] = fl[x]] = true);
      while (x != -1) swap(x, fr[fl[x] = pre[x]]);
      return false;
    };
    while (true) {
      while (l < r)
        for (int x = 0, y = q[l++]; x < n; ++x) if (!vl[x])
          if (chmin(slk[x], hl[x] + hr[y] - w[x][y]))
            if (pre[x] = y, !check(x)) return;
      lld d = ranges::min(slk);
      for (int x = 0; x < n; ++x)
        vl[x] ? hl[x] += d : slk[x] -= d;
      for (int x = 0; x < n; ++x) if (vr[x]) hr[x] -= d;
      for (int x = 0; x < n; ++x) if (!check(x)) return;
    }
  }
  KM(int n_, const auto &w) : n(n_), ans(0),
    hl(n), hr(n), fl(n, -1), fr(fl), pre(n), q(n) {
    for (int i = 0; i < n; ++i) hl[i]=ranges::max(w[i]);
    for (int i = 0; i < n; ++i) bfs(w, i);
    for (int i = 0; i < n; ++i) ans += w[i][fl[i]];
  }
};

const int inf = 1e9;

signed main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n;
  cin >> n;
  vector<P3> p(n), v(n);

  for (int i = 0; i < n; i++) {
    cin >> p[i].x >> p[i].y >> p[i].z;
    cin >> v[i].x >> v[i].y >> v[i].z;
  }

  if (n == 1) {
    cout << -1 << '\n';
    return 0;
  }

  bool colinear = true;
  for (int i = 2; i < n; i++) {
    if (cross(p[i] - p[0], p[1] - p[0]) != P3(0, 0, 0)) {
      colinear = false;
      break;
    }
  }

  if (colinear && n % 2 == 1) {

    auto solveTwo = [&](int i, int j) {
      int res = 0;
      if (!same_dir(p[i] - p[j], v[j]))
        ++res;
      if (!same_dir(p[j] - p[i], v[i]))
        ++res;
      return res;
    };

    vector<int> idx(n);
    iota(all(idx), 0);
    sort(all(idx), [&](int a, int b) {
      return dot(p[a] - p[0], p[1] - p[0]) < dot(p[b] - p[0], p[1] - p[0]);
    });

    int ans = 1e9;
    for (int _ = 0; _ < 2; _++) {
      orange(all(idx));
      auto V = p[idx[1]] - p[idx[0]];

      for (int s = 0; s < n; s++) {
        auto tmp = idx;
        tmp.erase(find(all(tmp), s));

        vector<int> pre(n, inf);

        pre[0] = 0;
        for (int l = 0; l + 1 < ssize(tmp); l += 2) {
          pre[l + 2] = pre[l] + solveTwo(tmp[l], tmp[l + 1]);
        }

        for (int l = 0; l < n; l += 2) {
          int middle = 0;
          for (int r = l; r < n; r++) {
            if (r != l && r % 2 == 0) {

              int cur = middle + pre[l] + (pre[n - 1] - pre[r]);
              if (!same_dir(v[tmp[r - 1]], V)) {
                --cur;
              }

              Ray A(p[tmp[l]], -v[s]);
              Ray B(p[tmp[r - 1]], v[tmp[r - 1]]);

              bool left_colinear = cross(v[s], V) == P3(0, 0, 0);
              bool right_colinear = cross(v[tmp[r - 1]], V) == P3(0, 0, 0);
              debug(cur, l, r);
              debug(s, pre[l], pre[n - 1] - pre[r], middle);
              if (left_colinear || right_colinear) {
                cur += left_colinear;
                cur += right_colinear;
              } else if (!intersect(A, B)) {
                ++cur;
              }

              ans = min(ans, cur + 1000);
            }

            if (!same_dir(v[tmp[r]], V)) {
              ++middle;
            }
          }
        }
      }

      reverse(all(idx));
    }

    cout << ans << '\n';
    return 0;
  }

  auto w = vector(n, vector(n, -inf));

  for (int i = 0; i < n; i++) {
    map<P3, int> mp;
    for (int j = 0; j < n; j++) if (j != i) {
      auto r = reduced(p[j] - p[i]);
      debug(r.x, r.y, r.z);
      if (auto it = mp.find(r); it != mp.end()) {
        if (norm(p[it->second] - p[i]) > norm(p[j] - p[i])) {
          it->second = j;
        } else {
          debug(j, it->second);
          assert(norm(p[it->second] - p[i]) < norm(p[j] - p[i]));
        }
      } else {
        mp[r] = j;
      }
    }

    for (auto [_, j] : mp) {
      debug(i, j);
      if (same_dir(p[j] - p[i], v[i])) {
        w[i][j] = 1;
      } else {
        w[i][j] = 0;
      }
    }
  }

  auto ma = KM(n, w);

  cout << n - ma.ans << '\n';

}