#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <functional>
#include <complex>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <tuple>
using namespace std;
typedef long long LL;
typedef complex<double> CMP;
double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
bool point_in_polygon( vector<CMP>& ps, CMP p )
{
bool in = false;
for(int i=0; i<ps.size(); ++i) {
CMP a = ps[i] - p;
CMP b = ps[(i+1)%ps.size()] - p;
if(a.imag() > b.imag()) swap(a,b);
if(a.imag()<=0 && 0<b.imag()) {
if( outer_prod(a,b) < 0 )
in = !in;
}
}
return in;
}
class RedAndBluePoints { public:
int find(vector <int> blueX, vector <int> blueY, vector <int> redX, vector <int> redY)
{
const int B = blueX.size();
const int R = redX.size();
int best = 0;
for(int b_use=0; b_use<B; ++b_use)
{
vector<vector<int>> G(B);
for(int b1=0; b1<B; ++b1) if(b1 != b_use)
for(int b2=b1+1; b2<B; ++b2) if(b2 != b_use) {
bool bad = false;
vector<CMP> poly;
poly.emplace_back(blueX[b_use], blueY[b_use]);
poly.emplace_back(blueX[b1], blueY[b1]);
poly.emplace_back(blueX[b2], blueY[b2]);
for(int r=0; r<R; ++r)
if(point_in_polygon(poly, CMP(redX[r], redY[r])))
{ bad=true; break; }
if(bad) {
G[b1].push_back(b2);
G[b2].push_back(b1);
}
}
best = max(best, max_independent_set(G));
}
return best;
}
int max_independent_set(const vector<vector<int>>& G)
{
const int N = G.size();
vector<LL> badmask(G.size());
for(int v=0; v<N; ++v) {
LL x = 1LL<<v;
for(int u: G[v])
x |= 1LL<<u;
badmask[v] = x;
}
int best = 0;
function<void(int,LL,int)> rec = [&](int v, LL rest, int cur) {
if(best < cur)
best = cur;
if(rest == 0)
return;
if(cur + __builtin_popcountll(rest) <= best)
return;
LL r1 = rest &~ (1LL<<v);
LL r2 = rest &~ badmask[v];
if(rest & (1LL<<v)) {
if(r1 != r2) rec(v+1, r1, cur);
rec(v+1, r2, cur+1);
} else {
rec(v+1, r1, cur);
}
};
rec(0, (1LL<<N)-1, 0);
return best;
}
};
// BEGIN CUT HERE
#include <ctime>
double start_time; string timer()
{ ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
{ os << "{ ";
for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
void verify_case(const int& Expected, const int& Received) {
bool ok = (Expected == Received);
if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl;
cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
#define END verify_case(_, RedAndBluePoints().find(blueX, blueY, redX, redY));}
int main(){
CASE(0)
int blueX_[] = {0,0,10,10};
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = {0,10,0,10};
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = {100};
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = {120};
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = 4;
END
CASE(1)
int blueX_[] = {0,0,10,10};
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = {0,10,0,10};
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = {3};
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = {4};
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = 3;
END
CASE(2)
int blueX_[] = {0,0,10,10};
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = {0,10,0,10};
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = {3,6};
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = {2,7};
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = 2;
END
CASE(3)
int blueX_[] = {0};
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = {0};
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = {1};
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = {1};
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = 1;
END
CASE(4)
int blueX_[] = {5, 6, 6};
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = {9, 0, 5};
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = {7};
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = {6};
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = 3;
END
/*
CASE(5)
int blueX_[] = ;
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = ;
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = ;
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = ;
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = ;
END
CASE(6)
int blueX_[] = ;
vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
int blueY_[] = ;
vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
int redX_[] = ;
vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
int redY_[] = ;
vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
int _ = ;
END
*/
}
// END CUT HERE