892b20bec8 2015-04-28        kinaba: #include <iostream>
892b20bec8 2015-04-28        kinaba: #include <sstream>
892b20bec8 2015-04-28        kinaba: #include <iomanip>
892b20bec8 2015-04-28        kinaba: #include <vector>
892b20bec8 2015-04-28        kinaba: #include <string>
892b20bec8 2015-04-28        kinaba: #include <map>
892b20bec8 2015-04-28        kinaba: #include <set>
892b20bec8 2015-04-28        kinaba: #include <algorithm>
892b20bec8 2015-04-28        kinaba: #include <numeric>
892b20bec8 2015-04-28        kinaba: #include <iterator>
892b20bec8 2015-04-28        kinaba: #include <functional>
892b20bec8 2015-04-28        kinaba: #include <complex>
892b20bec8 2015-04-28        kinaba: #include <queue>
892b20bec8 2015-04-28        kinaba: #include <stack>
892b20bec8 2015-04-28        kinaba: #include <cmath>
892b20bec8 2015-04-28        kinaba: #include <cassert>
892b20bec8 2015-04-28        kinaba: #include <tuple>
892b20bec8 2015-04-28        kinaba: using namespace std;
892b20bec8 2015-04-28        kinaba: typedef long long LL;
892b20bec8 2015-04-28        kinaba: typedef complex<double> CMP;
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: double outer_prod(const CMP& a, const CMP& b) { return imag(conj(a)*b); }
892b20bec8 2015-04-28        kinaba: double inner_prod(const CMP& a, const CMP& b) { return real(conj(a)*b); }
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: int ccw(const CMP& a, CMP b, CMP c) {
892b20bec8 2015-04-28        kinaba: 	b -= a; c -= a;
892b20bec8 2015-04-28        kinaba: 	if( outer_prod(b,c) > 0 ) return +1; // counter clockwise
892b20bec8 2015-04-28        kinaba: 	if( outer_prod(b,c) < 0 ) return -1; // clockwise
892b20bec8 2015-04-28        kinaba: 	if( inner_prod(b,c) < 0 ) return +2; // c--a--b on line
892b20bec8 2015-04-28        kinaba: 	if( norm(b) < norm(c) )   return -2; // a--b--c on line
892b20bec8 2015-04-28        kinaba: 	return 0;
892b20bec8 2015-04-28        kinaba: }
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: bool byX( const CMP& a, const CMP& b ) {
892b20bec8 2015-04-28        kinaba: 	if( a.real() != b.real() )
892b20bec8 2015-04-28        kinaba: 		return a.real() < b.real();
892b20bec8 2015-04-28        kinaba: 	return a.imag() < b.imag();
892b20bec8 2015-04-28        kinaba: }
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: vector<CMP> convex_hull( vector<CMP> p )
892b20bec8 2015-04-28        kinaba: {
892b20bec8 2015-04-28        kinaba: 	#define IS_RIGHT <0   // skip on-line verts
892b20bec8 2015-04-28        kinaba: 	//#define IS_RIGHT ==-1 // take all
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 	sort(p.begin(), p.end(), &byX);
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 	vector<CMP> ans;
892b20bec8 2015-04-28        kinaba: 	for(int i=0; i<p.size(); ans.push_back(p[i++])) // left-to-right
892b20bec8 2015-04-28        kinaba: 		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
892b20bec8 2015-04-28        kinaba: 			ans.pop_back();
892b20bec8 2015-04-28        kinaba: 	if( ans.size() == p.size() )
892b20bec8 2015-04-28        kinaba: 		return ans;
892b20bec8 2015-04-28        kinaba: 	for(int i=p.size()-2; i>=0; ans.push_back(p[i--])) // right-to-left
892b20bec8 2015-04-28        kinaba: 		while( ans.size()>=2 && ccw(ans[ans.size()-2], ans[ans.size()-1], p[i]) IS_RIGHT )
892b20bec8 2015-04-28        kinaba: 			ans.pop_back();
892b20bec8 2015-04-28        kinaba: 	ans.pop_back();
892b20bec8 2015-04-28        kinaba: 	return ans;
892b20bec8 2015-04-28        kinaba: }
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: bool point_in_polygon( vector<CMP>& ps, CMP p )
892b20bec8 2015-04-28        kinaba: {
892b20bec8 2015-04-28        kinaba: 	bool in = false;
892b20bec8 2015-04-28        kinaba: 	for(int i=0; i<ps.size(); ++i) {
892b20bec8 2015-04-28        kinaba: 		CMP a = ps[i] - p;
892b20bec8 2015-04-28        kinaba: 		CMP b = ps[(i+1)%ps.size()] - p;
892b20bec8 2015-04-28        kinaba: 		if(a.imag() > b.imag()) swap(a,b);
892b20bec8 2015-04-28        kinaba: 		if(a.imag()<=0 && 0<b.imag()) {
892b20bec8 2015-04-28        kinaba: 			if( outer_prod(a,b) < 0 )
892b20bec8 2015-04-28        kinaba: 				in = !in;
892b20bec8 2015-04-28        kinaba: 		}
892b20bec8 2015-04-28        kinaba: 		//if( outer_prod(a,b)==0 && inner_prod(a,b)<=0 ) return ON;
892b20bec8 2015-04-28        kinaba: 	}
892b20bec8 2015-04-28        kinaba: 	return in;
892b20bec8 2015-04-28        kinaba: }
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: class BichromeSky { public:
892b20bec8 2015-04-28        kinaba: 	double totallyCovered(vector <int> redX, vector <int> redY, vector <int> prob, vector <int> blueX, vector <int> blueY)
892b20bec8 2015-04-28        kinaba: 	{
892b20bec8 2015-04-28        kinaba: 		vector<CMP> blue;
892b20bec8 2015-04-28        kinaba: 		for(int i=0; i<blueX.size(); ++i)
892b20bec8 2015-04-28        kinaba: 			blue.emplace_back(CMP(blueX[i], blueY[i]));
892b20bec8 2015-04-28        kinaba: 		blue = convex_hull(blue);
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		vector<CMP> red;
892b20bec8 2015-04-28        kinaba: 		vector<double> p_red;
892b20bec8 2015-04-28        kinaba: 		for(int i=0; i<redX.size(); ++i) {
892b20bec8 2015-04-28        kinaba: 			CMP p = CMP(redX[i], redY[i]);
892b20bec8 2015-04-28        kinaba: 			if(!point_in_polygon(blue, p)) {
892b20bec8 2015-04-28        kinaba: 				red.emplace_back(p);
892b20bec8 2015-04-28        kinaba: 				p_red.emplace_back(prob[i] / 1000.0);
892b20bec8 2015-04-28        kinaba: 			}
892b20bec8 2015-04-28        kinaba: 		}
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		// trivial
892b20bec8 2015-04-28        kinaba: 		if(red.size() <= 2)
892b20bec8 2015-04-28        kinaba: 			return 0.0;
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		// trivial
892b20bec8 2015-04-28        kinaba: 		vector<CMP> red_hull = convex_hull(red);
892b20bec8 2015-04-28        kinaba: 		for(auto p: blue)
892b20bec8 2015-04-28        kinaba: 			if(!point_in_polygon(red_hull, p))
892b20bec8 2015-04-28        kinaba: 				return 0.0;
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		vector<pair<CMP,double>> rp;
892b20bec8 2015-04-28        kinaba: 		for(int i=0; i<red.size(); ++i)
892b20bec8 2015-04-28        kinaba: 			rp.emplace_back(red[i], p_red[i]);
892b20bec8 2015-04-28        kinaba: 		const int N = rp.size();
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		CMP base = *min_element(red.begin(), red.end(), [](const CMP& lhs, const CMP& rhs){
892b20bec8 2015-04-28        kinaba: 			if(lhs.imag() != rhs.imag()) return lhs.imag() < rhs.imag();
892b20bec8 2015-04-28        kinaba: 			return lhs.real() < rhs.real();
892b20bec8 2015-04-28        kinaba: 		});
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		sort(rp.begin(), rp.end(), [&](const pair<CMP,double>& lhs, const pair<CMP,double>& rhs) {
892b20bec8 2015-04-28        kinaba: 			if(lhs == rhs) return false;
892b20bec8 2015-04-28        kinaba: 			if(lhs.first == base) return true;
892b20bec8 2015-04-28        kinaba: 			if(rhs.first == base) return false;
892b20bec8 2015-04-28        kinaba: 			return arg(lhs.first - base) < arg(rhs.first - base);
892b20bec8 2015-04-28        kinaba: 		});
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		function<bool(int,int)> is_right_of_blue = [&](int ai, int bi) {
892b20bec8 2015-04-28        kinaba: 			CMP a = rp[ai%N].first;
892b20bec8 2015-04-28        kinaba: 			CMP b = rp[bi%N].first;
892b20bec8 2015-04-28        kinaba: 			for(CMP p: blue)
892b20bec8 2015-04-28        kinaba: 				if(ccw(a, b, p) != +1)
892b20bec8 2015-04-28        kinaba: 					return false;
892b20bec8 2015-04-28        kinaba: 			return true; // TODO
892b20bec8 2015-04-28        kinaba: 		};
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		function<double(int,int)> rec;
892b20bec8 2015-04-28        kinaba: 		map<pair<int,int>, double> memo;
892b20bec8 2015-04-28        kinaba: 		rec = [&](int done_from, int done_to) {
892b20bec8 2015-04-28        kinaba: 			if(done_from == done_to)
892b20bec8 2015-04-28        kinaba: 				return 1.0;
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 			pair<int,int> key(done_from, done_to);
892b20bec8 2015-04-28        kinaba: 			if(memo.count(key))
892b20bec8 2015-04-28        kinaba: 				return memo[key];
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 			double total = 0.0;
892b20bec8 2015-04-28        kinaba: 			double pp = 1.0;
892b20bec8 2015-04-28        kinaba: 			for(int next=done_to+1; next<=done_from; ++next) {
892b20bec8 2015-04-28        kinaba: 				if(is_right_of_blue(done_to, next)) {
892b20bec8 2015-04-28        kinaba: 					total += pp * (next==done_from ? 1.0 : rp[next].second) * rec(next, done_from);
892b20bec8 2015-04-28        kinaba: 				}
892b20bec8 2015-04-28        kinaba: 				pp *= 1.0 - rp[next].second;
892b20bec8 2015-04-28        kinaba: 			}
892b20bec8 2015-04-28        kinaba: 			return memo[key] = total;
892b20bec8 2015-04-28        kinaba: 		};
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		double ans = 0.0;
892b20bec8 2015-04-28        kinaba: 		for(int from=N; from>=2; --from)
892b20bec8 2015-04-28        kinaba: 		for(int to=1; to<from; ++to) {
892b20bec8 2015-04-28        kinaba: 			if(is_right_of_blue(from, to)) {
892b20bec8 2015-04-28        kinaba: 				double pp = 1.0;
892b20bec8 2015-04-28        kinaba: 				for(int k=(from+1)%N; k!=to; k=(k+1)%N)
892b20bec8 2015-04-28        kinaba: 					pp *= 1.0 - rp[k].second;
892b20bec8 2015-04-28        kinaba: 				ans += rp[from%N].second * rp[to].second * pp * rec(from, to);
892b20bec8 2015-04-28        kinaba: 			}
892b20bec8 2015-04-28        kinaba: 		}
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: 		return ans;
892b20bec8 2015-04-28        kinaba: 	}
892b20bec8 2015-04-28        kinaba: };
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: // BEGIN CUT HERE
892b20bec8 2015-04-28        kinaba: #include <ctime>
892b20bec8 2015-04-28        kinaba: double start_time; string timer()
892b20bec8 2015-04-28        kinaba:  { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
892b20bec8 2015-04-28        kinaba: template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
892b20bec8 2015-04-28        kinaba:  { os << "{ ";
892b20bec8 2015-04-28        kinaba:    for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
892b20bec8 2015-04-28        kinaba:    os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
892b20bec8 2015-04-28        kinaba: void verify_case(const double& Expected, const double& Received) {
892b20bec8 2015-04-28        kinaba:  bool ok = (abs(Expected - Received) < 1e-9);
892b20bec8 2015-04-28        kinaba:  if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
892b20bec8 2015-04-28        kinaba:  cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
892b20bec8 2015-04-28        kinaba: #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
892b20bec8 2015-04-28        kinaba: #define END	 verify_case(_, BichromeSky().totallyCovered(redX, redY, prob, blueX, blueY));}
892b20bec8 2015-04-28        kinaba: int main(){
892b20bec8 2015-04-28        kinaba: 
892b20bec8 2015-04-28        kinaba: CASE(0)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = {3,-3,0};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = {-1,-1,2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = {400,500,600};
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = {1,0,-1};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = {0,1,0};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = 0.12;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: CASE(1)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = {3,-3,3,-3};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = {3,3,-3,-3};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = {200,300,400,500};
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = {0,1,-1};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = {-1,-2,-2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = 0.088;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: CASE(2)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = {3,-3,0};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = {-1,-1,2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = {400,500,600};
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = {1,0,-1,123456};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = {0,1,0,-654321};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = 0.0;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: CASE(3)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = {0,-2,-3,-4,-3,-2,0,2,3,4,3,2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = {4,3,2,0,-2,-3,-4,-3,-2,0,2,3};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = {501,502,503,504,505,506,507,508,509,510,511,512};
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = {1,-1,-1,1};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = {1,1,-1,-1};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = 0.6555037822772468;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: CASE(4)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = {0,1,-3,3};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = {0,4,-2,-2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = {200,300,400,500};
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = {0,-1,1};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = {1,-1,-1};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = 0.06;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: CASE(5)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = {10,-17,12,-11,-13,-10,-15,14,-4,2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = {8,17,-13,-19,-14,11,17,8,-8,-15};
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = {412,360,656,876,984,160,368,873,223,128};
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = {-9,-3,6,-9,-5,4,-3,10,-7,2};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = {-6,10,10,-9,-10,-6,2,-10,-9,6};
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = 0.34037052019900405;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: /*
892b20bec8 2015-04-28        kinaba: CASE(6)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = ;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: CASE(7)
892b20bec8 2015-04-28        kinaba: 	int redX_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> redX(redX_, redX_+sizeof(redX_)/sizeof(*redX_));
892b20bec8 2015-04-28        kinaba: 	int redY_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> redY(redY_, redY_+sizeof(redY_)/sizeof(*redY_));
892b20bec8 2015-04-28        kinaba: 	int prob_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> prob(prob_, prob_+sizeof(prob_)/sizeof(*prob_));
892b20bec8 2015-04-28        kinaba: 	int blueX_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueX(blueX_, blueX_+sizeof(blueX_)/sizeof(*blueX_));
892b20bec8 2015-04-28        kinaba: 	int blueY_[] = ;
892b20bec8 2015-04-28        kinaba: 	  vector <int> blueY(blueY_, blueY_+sizeof(blueY_)/sizeof(*blueY_));
892b20bec8 2015-04-28        kinaba: 	double _ = ;
892b20bec8 2015-04-28        kinaba: END
892b20bec8 2015-04-28        kinaba: */
892b20bec8 2015-04-28        kinaba: }
892b20bec8 2015-04-28        kinaba: // END CUT HERE