classSolution {

template<typename A,typename B,typename C>

structTupleHash {

size_toperator()(const tuple<A, B, C>& p)const {

size_t seed =0;

A a; B b; C c;

tie(a, b, c) = p;

seed ^= std::hash<A>{}(a) +0x9e3779b9 + (seed<<6) + (seed>>2);

seed ^= std::hash<B>{}(b) +0x9e3779b9 + (seed<<6) + (seed>>2);

seed ^= std::hash<C>{}(c) +0x9e3779b9 + (seed<<6) + (seed>>2);

return seed;

}

};

template<typename T>

structPairHash {

size_toperator()(const pair<T, T>& p)const {

size_t seed =0;

seed ^= std::hash<T>{}(p.first) +0x9e3779b9 + (seed<<6) + (seed>>2);

seed ^= std::hash<T>{}(p.second) +0x9e3779b9 + (seed<<6) + (seed>>2);

return seed;

template<typename... T>

std::size_toperator()(const std::tuple<T...>& t)const {

returnapply([](constauto&... args) {

std::size_t seed =0;

((seed ^= std::hash<std::decay_t<decltype(args)>>{}(args) +

0x9e3779b9 + (seed <<6) + (seed >>2)), ...);

return seed;

}, t);

}

};

auto ceil_divide = [](int a,int b) {

return (a + b -1) / b;

};

unordered_map<tuple<int,int,int>, unordered_set<pair<int,int>,PairHash<int>>, TupleHash<int,int,int>> lookup;

unordered_map<tuple<int,int,int>, unordered_set<tuple<int,int>,TupleHash>, TupleHash> lookup;

for (int i =0; i <size(points); ++i) {

constint x1 = points[i][0], y1 = points[i][1];

for (int j = i +1; j <size(points); ++j) {

int c = x1 * (y2 - y1) - y1 * (x2 - x1);

constint g =gcd(gcd(a, b), c);

a /= g, b /= g, c /= g;

for (constauto& x : {a, b, c}) {

if (x) {

if (x <0) {

a = -a, b = -b, c = -c;

}

break;

}

}

lookup[{a, b, c}].emplace(x1, y1);

lookup[{a, b, c}].emplace(x2, y2);

}

int result = numeric_limits<int>::max();

constint mask_upper_bound =1 <<size(lines);

for (int mask =0; mask < mask_upper_bound; ++mask) {

unordered_set<pair<int,int>,PairHash<int>> covered;

unordered_set<tuple<int,int>,TupleHash> covered;

for (int i =0, bit =1; bit <= mask; bit <<=1, ++i) {

if (mask & bit) {

for (constauto& x : lookup[lines[i]]) {