ADDED   SRM/679/1A.cpp
Index: SRM/679/1A.cpp
==================================================================
--- SRM/679/1A.cpp
+++ SRM/679/1A.cpp
@@ -0,0 +1,125 @@
+#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;
+
+class FiringEmployees { public:
+	int fire(vector <int> manager, vector <int> salary, vector <int> productivity)
+	{
+		const int N = manager.size()+1;
+
+		vector<vector<int>> children(N);
+		for(int i=1; i<N; ++i)
+			children[manager[i-1]].push_back(i);
+
+		vector<int> best(N);
+		for(int i=N-1; i>=0; --i) {
+			int total = (i ? productivity[i-1] - salary[i-1] : 0);
+			for(int u: children[i])
+				total += best[u];
+			if(total > 0)
+				best[i] = total;
+		}
+		return best[0];
+	}
+};
+
+// 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(_, FiringEmployees().fire(manager, salary, productivity));}
+int main(){
+
+CASE(0)
+	int manager_[] = {0,0,0};
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = {1,2,3};
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = {3,2,1};
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = 2; 
+END
+CASE(1)
+	int manager_[] = {0,1,2,3};
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = {4,3,2,1};
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = {2,3,4,5};
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = 4; 
+END
+CASE(2)
+	int manager_[] = {0,1};
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = {1,10};
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = {5,5};
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = 4; 
+END
+CASE(3)
+	int manager_[] = {0,1,2,1,2,3,4,2,3};
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = {5,3,6,8,4,2,4,6,7};
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = {2,5,7,8,5,3,5,7,9};
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = 6; 
+END
+CASE(4)
+	int manager_[] = {0,0,1,1,2,2};
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = {1,1,1,2,2,2};
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = {2,2,2,1,1,1};
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = 3; 
+END
+/*
+CASE(5)
+	int manager_[] = ;
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = ;
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = ;
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = ; 
+END
+CASE(6)
+	int manager_[] = ;
+	  vector <int> manager(manager_, manager_+sizeof(manager_)/sizeof(*manager_)); 
+	int salary_[] = ;
+	  vector <int> salary(salary_, salary_+sizeof(salary_)/sizeof(*salary_)); 
+	int productivity_[] = ;
+	  vector <int> productivity(productivity_, productivity_+sizeof(productivity_)/sizeof(*productivity_)); 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/679/1B.cpp
Index: SRM/679/1B.cpp
==================================================================
--- SRM/679/1B.cpp
+++ SRM/679/1B.cpp
@@ -0,0 +1,201 @@
+#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

ADDED   SRM/679/1C.cpp
Index: SRM/679/1C.cpp
==================================================================
--- SRM/679/1C.cpp
+++ SRM/679/1C.cpp
@@ -0,0 +1,135 @@
+#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;
+
+static const int MODVAL = 1000000007;
+class BagAndCards { public:
+	int getHash(int n, int m, int x, int a, int b, int c, string isGood)
+	{
+		vector<vector<int>> count(n, vector<int>(m, 0));
+		for(int i=0; i<n; ++i)
+		for(int j=0; j<m; ++j) {
+			count[i][j] = x;
+			x = int(((LL(x) * a + b) ^ c) % MODVAL);
+		}
+
+		int total_ans = 0;
+		for(int i=0; i<n; ++i)
+		{
+			vector<LL> mult(m);
+			for(int c1=0; c1<m; ++c1)
+			for(int c2=0; c2<m; ++c2)
+				if(isGood[c1+c2]=='Y')
+					mult[c2] += count[i][c1];
+			for(int c=0; c<m; ++c)
+				mult[c] %= MODVAL;
+
+			for(int k=i+1; k<n; ++k)
+			{
+				LL ans = 0;
+				for(int c=0; c<m; ++c)
+					ans += count[k][c] * mult[c] % MODVAL;
+				total_ans ^= int(ans % MODVAL);
+			}
+		}
+		return total_ans;
+	}
+};
+
+// 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(_, BagAndCards().getHash(n, m, x, a, b, c, isGood));}
+int main(){
+
+CASE(0)
+	int n = 2; 
+	int m = 4; 
+	int x = 1; 
+	int a = 1; 
+	int b = 0; 
+	int c = 0; 
+	string isGood = "NNYYNYN"; 
+	int _ = 9; 
+END
+CASE(1)
+	int n = 3; 
+	int m = 5; 
+	int x = 1; 
+	int a = 1; 
+	int b = 1; 
+	int c = 2; 
+	string isGood = "NNYYNYNYN"; 
+	int _ = 1532; 
+END
+CASE(2)
+	int n = 10; 
+	int m = 20; 
+	int x = 111; 
+	int a = 222; 
+	int b = 333; 
+	int c = 444; 
+	string isGood = "NNNNNYYYNNNYYYYYYNNYYYYNNNNYNNYYYNNNYYN" ; 
+	int _ = 450750683; 
+END
+CASE(3)
+	int n = 2; 
+	int m = 2; 
+	int x = 1; 
+	int a = 1; 
+	int b = 0; 
+	int c = 0; 
+	string isGood = "NNY"; 
+	int _ = 1; 
+END
+/*
+CASE(4)
+	int n = ; 
+	int m = ; 
+	int x = ; 
+	int a = ; 
+	int b = ; 
+	int c = ; 
+	string isGood = ; 
+	int _ = ; 
+END
+CASE(5)
+	int n = ; 
+	int m = ; 
+	int x = ; 
+	int a = ; 
+	int b = ; 
+	int c = ; 
+	string isGood = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   lib/graph/maxIndependentSet.cpp
Index: lib/graph/maxIndependentSet.cpp
==================================================================
--- lib/graph/maxIndependentSet.cpp
+++ lib/graph/maxIndependentSet.cpp
@@ -0,0 +1,41 @@
+//-------------------------------------------------------------
+// Bruteforuce O(2^V) search with trivial edagari.
+//
+// |V| must be <= 63
+//
+// Verified by
+//   - SRM 679 Div1 Lv2
+//-------------------------------------------------------------
+
+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;
+}