ADDED   SRM/562-U/1A-U.cpp
Index: SRM/562-U/1A-U.cpp
==================================================================
--- SRM/562-U/1A-U.cpp
+++ SRM/562-U/1A-U.cpp
@@ -0,0 +1,167 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<LD> CMP;
+
+class PastingPaintingDivOne { public:
+	vector<long long> countColors(vector <string> c, int T)
+	{
+		int H = c.size();
+		int W = c[0].size();
+
+		int TR = min(T, 50+T%50);
+		vector<string> shifted(H+TR+50, string(W+H, '.'));
+
+		// TR
+		for(int i=0; i<TR; ++i)
+			for(int y=0; y<H; ++y)
+			for(int x=0; x<W; ++x)
+				if(c[y][x] != '.')
+					shifted[i+y][x+H-1-y] = c[y][x];
+
+		LL r=0, g=0, b=0;
+		for(int y=0; y<shifted.size(); ++y)
+		for(int x=0; x<shifted[y].size(); ++x)
+			if(shifted[y][x]=='R') r++;
+			else if(shifted[y][x]=='G') g++;
+			else if(shifted[y][x]=='B') b++;
+
+		// 50 more
+		for(int i=TR; i<TR+50; ++i)
+			for(int y=0; y<H; ++y)
+			for(int x=0; x<W; ++x)
+				if(c[y][x] != '.')
+					shifted[i+y][x+H-1-y] = c[y][x];
+
+		LL rr=0, gg=0, bb=0;
+		for(int y=0; y<shifted.size(); ++y)
+		for(int x=0; x<shifted[y].size(); ++x)
+			if(shifted[y][x]=='R') rr++;
+			else if(shifted[y][x]=='G') gg++;
+			else if(shifted[y][x]=='B') bb++;
+
+		vector<LL> answer;
+		answer.push_back((rr-r)*(T-TR)/50 + r);
+		answer.push_back((gg-g)*(T-TR)/50 + g);
+		answer.push_back((bb-b)*(T-TR)/50 + b);
+		return answer;
+	}
+};
+
+// 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 vector<long long>& Expected, const vector<long long>& 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(_, PastingPaintingDivOne().countColors(clipboard, T));}
+int main(){
+
+CASE(0)
+	string clipboard_[] = {
+"..G",
+"R..",
+"BG."
+};
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = 3; 
+	long long __[] = {3, 4, 3 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string clipboard_[] = {
+"R...",
+"....",
+"....",
+"...R"
+};
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = 2; 
+	long long __[] = {4, 0, 0 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	string clipboard_[] = {"RGB"};
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = 100000; 
+	long long __[] = {100000, 100000, 100000 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string clipboard_[] = {"."};
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = 1000000000; 
+	long long __[] = {0, 0, 0 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string clipboard_[] = {
+"RB.",
+".G."
+}
+;
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = 100; 
+	long long __[] = {100, 1, 100 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	string clipboard_[] = {
+"..........G..........",
+".........G.G.........",
+"........G...G........",
+".......G.....G.......",
+"......G..B.B..G......",
+".....G...B.B...G.....",
+"....G...........G....",
+"...G...R.....R...G...",
+"..G.....RRRRRR....G..",
+".G..........RR.....G.",
+"GGGGGGGGGGGGGGGGGGGGG"
+};
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = 1000000000; 
+	long long __[] = {2000000018, 17000000048, 2000000005 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(6)
+	string clipboard_[] = ;
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = ; 
+	long long __[] = ;
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(7)
+	string clipboard_[] = ;
+	  vector <string> clipboard(clipboard_, clipboard_+sizeof(clipboard_)/sizeof(*clipboard_)); 
+	int T = ; 
+	long long __[] = ;
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/562-U/1B-U.cpp
Index: SRM/562-U/1B-U.cpp
==================================================================
--- SRM/562-U/1B-U.cpp
+++ SRM/562-U/1B-U.cpp
@@ -0,0 +1,227 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CheckerFreeness { public:
+	string isFree(vector <string> whiteX, vector <string> whiteY, vector <string> blackX, vector <string> blackY)
+	{
+		stringstream swx(accumulate(whiteX.begin(), whiteX.end(), string("")));
+		stringstream swy(accumulate(whiteY.begin(), whiteY.end(), string("")));
+		stringstream sbx(accumulate(blackX.begin(), blackX.end(), string("")));
+		stringstream sby(accumulate(blackY.begin(), blackY.end(), string("")));
+
+		vector<CMP> w;
+		for(int x,y; (swx>>x)&&(swy>>y); )
+			w.push_back(CMP(x,y));
+
+		vector<CMP> b;
+		for(int x,y; (sbx>>x)&&(sby>>y); )
+			b.push_back(CMP(x,y));
+
+		return has_checker(w,b) ? "NO" : "YES";
+	}
+
+	bool has_checker(const vector<CMP>& w, const vector<CMP>& b)
+	{
+		for(int i=0; i<w.size(); ++i)
+		for(int k=i+1; k<w.size(); ++k)
+			if(has_crosser(w[i], w[k], b))
+				return true;
+		return false;
+	}
+
+	bool has_crosser(CMP a, CMP b, const vector<CMP>& ps)
+	{
+		vector<double> arg_a, arg_b;
+		vector<CMP> qs;
+		for(int i=0; i<ps.size(); ++i)
+		{
+			double d = arg( (ps[i]-a)/(b-a) );
+			if(d > 0) {
+				arg_a.push_back(d);
+				d = arg( (ps[i]-b)/(b-a) );
+				arg_b.push_back(d);
+			} else {
+				qs.push_back(ps[i]);
+			}
+		}
+		sort(arg_a.begin(), arg_a.end());
+		sort(arg_b.begin(), arg_b.end());
+		for(int i=0; i<qs.size(); ++i)
+		{
+			CMP q = qs[i];
+			double aMax = arg((a-q) / (b-a));
+			double bMax = arg((b-q) / (b-a));
+			int aNum = lower_bound(arg_a.begin(), arg_a.end(), aMax) - arg_a.begin();
+			int bNum = lower_bound(arg_b.begin(), arg_b.end(), bMax) - arg_b.begin();
+			if(aNum != bNum)
+				return true;
+		}
+		return false;
+	}
+};
+
+// 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 string& Expected, const string& 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(_, CheckerFreeness().isFree(whiteX, whiteY, blackX, blackY));}
+int main(){
+
+CASE(0)
+	string whiteX_[] = {"1 2"};
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = {"2 1"};
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = {"1 2"};
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = {"1 2"};
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = "NO"; 
+END
+CASE(1)
+	string whiteX_[] = {"2", "5", "3", " ", "1", "7", "3"};
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = {"180 254"};
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = {"32", "5 1", "42"};
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = {"462 423"};
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = "YES"; 
+END
+CASE(2)
+	string whiteX_[] = {"1 10000000 9999999"};
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = {"1 9999999 1"};
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = {"2 5000000 9999998"};
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = {"2 5000001 9999999"};
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = "YES"; 
+END
+CASE(3)
+	string whiteX_[] = {"1"};
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = {"2"};
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = {"3"};
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = {"4"};
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = "YES"; 
+END
+CASE(4)
+	string whiteX_[] = {"6115 9723 3794 2275 2268 2702 3657 915 7953 2743 7"
+,"716 9645 2547 9490 9365 326 6601 5215 6771 7153 72"
+,"93 5922 714 2258 4369 9524 302 8417 6620 1143"};
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = {"621 1611 7140 503 5345 7202 681 4908 2510 5908 279"
+,"6 6286 6873 6682 9197 6710 8517 1913 7784 8533 665"
+,"4 446 3561 7241 6168 2025 4739 9501 5340 6446"};
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = {"6833 131 4151 1776 1959 7210 1903 6107 598 6220 94"
+,"24 5374 6718 2919 6068 6644 5070 710 7121 1630 370"
+,"3 1051 5739 9294 8798 3371 8107 2130 6608 534"};
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = {"7496 2412 2801 3473 5810 2714 7853 9714 5470 3558 "
+,"8143 2391 8234 7292 9311 1636 8978 1107 2262 9175 "
+,"7259 8842 5294 7209 2317 3825 3413 820 3774 5393"};
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = "NO"; 
+END
+CASE(5)
+	string whiteX_[] = {"219211 1996214 1706774 3634920 909831 1774128 8503"
+,"52 2233050 2099138 3380396 1128982 3682525 1483700"
+," 763080 487867 8203 1791027 463556 1103323 1406861"
+," 6374234 760949 4340236 727393 2073832 1289052 103"
+,"8147 4448130 151066 412440 1068735 377239 2677933 "
+,"1299598 339843 289973 3707319 555280 230418 431719"};
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = {"1638083 5698739 3105504 9726902 9745795 5049444 15"
+,"80592 3952120 6606668 7460527 7239299 8726128 4913"
+,"547 6264100 5701660 8865937 4969114 8014845 327236"
+,"1 6389154 9739755 2561669 9412417 5452337 3150506 "
+,"5832197 1571976 8779325 3306446 948271 5133709 949"
+,"394 6919798 7525636 3568024 6833196 9237472 733313"
+,"1 9939064 9720014"};
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = {"5860334 8007503 7455523 4864927 9573526 2718360 81"
+,"12104 6684287 9921506 4840886 5415948 3451454 5320"
+,"996 9268757 9261724 8254668 2292750 8035828 233352"
+,"1 7676906 5234406 8533320 6562751 4884098 4971897 "
+,"5569360 8519168 3100295 9351613 7733878 7579030 32"
+,"46775 7297460 8370542 7099759 5782969 2978083 3390"
+,"488 7482758 1332401 6094629 9717305 5503121 572842"
+,"1 4903563 6331656 2867455 3410007 7751527 7228221 "
+,"4111694 5171296 6847697 4601273 7599828 5515929 94"
+,"60593 9332762 5389080 4512091 8668538 5711743 5838"
+,"534 4825079 8145628 3810005 2964724 5594550 785748"
+,"3 6283769"};
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = {"5911694 8009943 212555 5838688 9896256 607434 5857"
+,"663 4616750 1477573 7168026 3090917 4379806 326465"
+,"7 4189076 2104028 3279691 94211 8503556 78457 4394"
+,"360 3344176 3223317 2624498 4883494 1532240 732937"
+,"1 1518674 1353567 892134 5536454 8527392 2603965 6"
+,"623264 8830827 2030444 3002706 83058 4475866 20876"
+,"25 1790695 4034441 5409379 3571098 4600050 736561 "
+,"250475 3733256 3011439 2144994 4523046 3119883 607"
+,"582 8361403 6525451 7518329 926803 4884524 8424659"
+," 7088689 5762049 9532481 4914186 7314621 4339084 3"
+,"741685 3837953 3177252 612550 9688871 5872931"};
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = "YES"; 
+END
+/*
+CASE(6)
+	string whiteX_[] = ;
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = ;
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = ;
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = ;
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = ; 
+END
+CASE(7)
+	string whiteX_[] = ;
+	  vector <string> whiteX(whiteX_, whiteX_+sizeof(whiteX_)/sizeof(*whiteX_)); 
+	string whiteY_[] = ;
+	  vector <string> whiteY(whiteY_, whiteY_+sizeof(whiteY_)/sizeof(*whiteY_)); 
+	string blackX_[] = ;
+	  vector <string> blackX(blackX_, blackX_+sizeof(blackX_)/sizeof(*blackX_)); 
+	string blackY_[] = ;
+	  vector <string> blackY(blackY_, blackY_+sizeof(blackY_)/sizeof(*blackY_)); 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/562-U/1C-U.cpp
Index: SRM/562-U/1C-U.cpp
==================================================================
--- SRM/562-U/1C-U.cpp
+++ SRM/562-U/1C-U.cpp
@@ -0,0 +1,224 @@
+#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>
+using namespace std;
+typedef long long LL;
+typedef long double LD;
+typedef complex<LD> CMP;
+
+static const unsigned MODVAL = 1000000009;
+struct mint
+{
+	unsigned val;
+	mint():val(0){}
+	mint(int      x):val(x%MODVAL) {}
+	mint(unsigned x):val(x%MODVAL) {}
+	mint(LL       x):val(x%MODVAL) {}
+};
+mint& operator+=(mint& x, mint y) { return x = x.val+y.val; }
+mint& operator-=(mint& x, mint y) { return x = x.val-y.val+MODVAL; }
+mint& operator*=(mint& x, mint y) { return x = LL(x.val)*y.val; }
+mint operator+(mint x, mint y) { return x+=y; }
+mint operator-(mint x, mint y) { return x-=y; }
+mint operator*(mint x, mint y) { return x*=y; }
+
+vector<mint> FAC_(1,1);
+mint FAC(LL n) { while( FAC_.size()<=n ) FAC_.push_back( FAC_.back()*FAC_.size() ); return FAC_[n]; }
+
+// nCk :: O(1) time, O(n^2) space.
+vector< vector<mint> > CP_;
+mint C(LL n, LL k) {
+	while( CP_.size() <= n ) {
+		int nn = CP_.size();
+		CP_.push_back(vector<mint>(nn+1,1));
+		for(int kk=1; kk<nn; ++kk)
+			CP_[nn][kk] = CP_[nn-1][kk-1] + CP_[nn-1][kk];
+	}
+	return k<0 || n<k ? 0 : CP_[n][k];
+}
+
+class InducedSubgraphs { public:
+	int getCount(vector <int> edge1, vector <int> edge2, int k)
+	{
+		int N = edge1.size()+1;
+		vector< vector<int> > G(N);
+		for(int i=0; i<edge1.size(); ++i)
+		{
+			int v = edge1[i], u = edge2[i];
+			G[v].push_back(u);
+			G[u].push_back(v);
+		}
+		return solve(G, N, k).val;
+	}
+
+	mint solve(const vector<vector<int> >& G, int N, int K)
+	{
+		mint total = 0;
+		for(int root=0; root<N; ++root)
+			total += solve_rooted(G, N, K, root);
+		return total;
+	}
+
+	mint solve_rooted(const vector<vector<int> >& G, int N, int K, int root)
+	{
+		memo.clear();
+
+		int pre = -1, cur = root;
+		for(int below=N,above=0 ;; --below,++above)
+			if(below <= K) {
+				mint b = rec(G, pre, cur).second;
+				mint a = (above>=K-1 ? mint(1) : FAC(K-above));
+				return b*a;
+			} else {
+				if((pre==-1 && G[cur].size()>=2) || G[cur].size()>=3) {
+					// fill_branch
+/*
+					vector< pair<int,int> > v_sz;
+					for(int k=0; k<G[cur].size(); ++k) if(G[cur][k] != pre)
+						v_sz.push_back(make_pair(G[cur][k], rec(G, cur, G[cur][k])));
+
+					int total_size = 0;
+					for(int k=0; k<v_sz.size(); ++k)
+						total_size += v_sz[k].second;
+					for(int k=0; k<v_sz.size(); ++k)
+						if( v_sz[k].second+1 <= K )
+*/
+					return 0;
+				}
+				
+				int nex = (G[cur][0]!=pre ? G[cur][0] : G[cur][1]);
+				pre = cur;
+				cur = nex;
+			}
+	}
+
+	// (size, number of toplofical sorting).
+	map<int, pair<int,mint> > memo;
+	pair<int,mint> rec(const vector<vector<int> >& G, int pre, int cur)
+	{
+		if(memo.count(cur))
+			return memo[cur];
+
+		vector< pair<int,mint> > children;
+		for(int i=0; i<G[cur].size(); ++i) if(G[cur][i] != pre)
+			children.push_back(rec(G, cur, G[cur][i]));
+
+		mint pat  = 1;
+		int  size = 0;
+		for(int i=0; i<children.size(); ++i) {
+			size += children[i].first;
+			pat   = pat * C(size, children[i].first) * children[i].second;
+		}
+		return memo[cur] = make_pair(size+1, pat);
+	}
+};
+
+// 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(_, InducedSubgraphs().getCount(edge1, edge2, k));}
+int main(){
+
+CASE(0)
+	int edge1_[] = {0, 1};
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {1, 2};
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 2; 
+	int _ = 2; 
+END
+CASE(1)
+	int edge1_[] = {0, 1, 3};
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {2, 2, 2};
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 3; 
+	int _ = 12; 
+END
+CASE(2)
+	int edge1_[] = {5, 0, 1, 2, 2};
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {0, 1, 2, 4, 3};
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 3; 
+	int _ = 4; 
+END
+CASE(3)
+	int edge1_[] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6};
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 11; 
+	int _ = 481904640; 
+END
+CASE(4)
+	int edge1_[] = {5, 9, 4, 10, 10, 0, 7, 6, 2, 1, 11, 8}
+;
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {0, 0, 10, 3, 0, 6, 1, 1, 12, 12, 7, 11}
+;
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 6; 
+	int _ = 800; 
+END
+CASE(5)
+	int edge1_[] = {0, 5, 1, 0, 2, 3, 5}
+;
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {4, 7, 0, 6, 7, 5, 0}
+;
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 3; 
+	int _ = 0; 
+END
+CASE(6)
+	int edge1_[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = 1; 
+	int _ = 890964601; 
+END
+/*
+CASE(7)
+	int edge1_[] = ;
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = ;
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = ; 
+	int _ = ; 
+END
+CASE(8)
+	int edge1_[] = ;
+	  vector <int> edge1(edge1_, edge1_+sizeof(edge1_)/sizeof(*edge1_)); 
+	int edge2_[] = ;
+	  vector <int> edge2(edge2_, edge2_+sizeof(edge2_)/sizeof(*edge2_)); 
+	int k = ; 
+	int _ = ; 
+END
+*/
+}
+// END CUT HERE