ADDED   SRM/621-U/1A.cpp
Index: SRM/621-U/1A.cpp
==================================================================
--- SRM/621-U/1A.cpp
+++ SRM/621-U/1A.cpp
@@ -0,0 +1,182 @@
+#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 RadioRange { public:
+	double RadiusProbability(vector <int> X, vector <int> Y, vector <int> R, int Z)
+	{
+		vector<pair<double, bool>> ev;
+
+		const int N = X.size();
+		for(int i=0; i<N; ++i)
+		{
+			double x = X[i];
+			double y = Y[i];
+			double r = R[i];
+			double d = sqrt(x*x+y*y);
+			// (s,e) is bad
+			double s = max(0.0, d-r);
+			double e = min(double(Z), d+r);
+			ev.emplace_back(s, true);
+			ev.emplace_back(e, false);
+		}
+
+		double total_bad = 0.0;
+
+		sort(ev.begin(), ev.end());
+		int nest = 0;
+		double prev_beg;
+		for(auto ei: ev) {
+			double x = ei.first;
+			bool beg = ei.second;
+			if(beg) {
+				if(++nest == 1)
+					prev_beg = x;
+			}
+			else {
+				if(--nest == 0)
+					total_bad += (x-prev_beg);
+			}
+		}
+
+		return (Z - total_bad) / Z;
+	}
+};
+
+// 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 double& Expected, const double& Received) {
+ bool ok = (abs(Expected - Received) < 1e-9);
+ 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(_, RadioRange().RadiusProbability(X, Y, R, Z));}
+int main(){
+
+CASE(0)
+	int X_[] = {0};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {5};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 10; 
+	double _ = 0.5; 
+END
+CASE(1)
+	int X_[] = {0};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {10};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 10; 
+	double _ = 0.0; 
+END
+CASE(2)
+	int X_[] = {10};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {10};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {10};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 10; 
+	double _ = 0.4142135623730951; 
+END
+CASE(3)
+	int X_[] = {11, -11, 0, 0};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0, 0, 11, -11};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {10, 10, 10, 10};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 31; 
+	double _ = 0.3548387096774194; 
+END
+CASE(4)
+	int X_[] = {100};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {100};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {1};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 10; 
+	double _ = 1.0; 
+END
+CASE(5)
+	int X_[] = {1000000000};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {1000000000};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {1000000000};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 1000000000; 
+	double _ = 0.41421356237309503; 
+END
+CASE(6)
+	int X_[] = {20, -20, 0, 0};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {0, 0, 20, -20};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {50, 50, 50, 50};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 100; 
+	double _ = 0.3; 
+END
+CASE(7)
+	int X_[] = {0, -60, -62, -60, 63, -97};
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = {-72, 67, 61, -8, -32, 89};
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = {6, 7, 8, 7, 5, 6};
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = 918; 
+	double _ = 0.9407071068962471; 
+END
+/*
+CASE(8)
+	int X_[] = ;
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = ;
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = ;
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = ; 
+	double _ = ; 
+END
+CASE(9)
+	int X_[] = ;
+	  vector <int> X(X_, X_+sizeof(X_)/sizeof(*X_)); 
+	int Y_[] = ;
+	  vector <int> Y(Y_, Y_+sizeof(Y_)/sizeof(*Y_)); 
+	int R_[] = ;
+	  vector <int> R(R_, R_+sizeof(R_)/sizeof(*R_)); 
+	int Z = ; 
+	double _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/621-U/1B-U.cpp
Index: SRM/621-U/1B-U.cpp
==================================================================
--- SRM/621-U/1B-U.cpp
+++ SRM/621-U/1B-U.cpp
@@ -0,0 +1,176 @@
+#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 TreesAnalysis { public:
+	typedef int EID;
+	int N;
+	long long treeSimilarity(vector <int> tree1, vector <int> tree2)
+	{
+		N = tree1.size() + 1;
+		vector<vector<pair<EID,int>>> T1(N);
+		vector<vector<int>> T2(N);
+		for(int v=0; v<N-1; ++v) {
+			int u = tree1[v];
+			T1[v].emplace_back(v, u);
+			T1[u].emplace_back(v+N, v);
+		}
+		for(int v=0; v<N-1; ++v) {
+			int u = tree2[v];
+			T2[v].push_back(u);
+			T2[u].push_back(v);
+		}
+
+		LL total = 0;
+		for(int v2=0; v2<N-1; ++v2) {
+			int u2 = tree2[v2];
+
+			function<void(int,int)> rec;
+			vector<bool> sub_vu(N), sub_uv(N, true);
+			rec = [&](int a, int b) {
+				sub_vu[b] = true;
+				sub_uv[b] = false;
+				for(int c: T2[b]) if(c!=a)
+					rec(b,c);
+			};
+			rec(v2, u2);
+
+			vector<int> memo_vu(2*N, -1), memo_uv(2*N, -1);
+			for(int v1=0; v1<N-1; ++v1) {
+				int u1 = tree1[v1];
+				int s1 = sim(T1, v1,   v1, u1, sub_vu, memo_vu);
+				int s2 = sim(T1, v1,   v1, u1, sub_uv, memo_uv);
+				int s3 = sim(T1, v1+N, u1, v1, sub_vu, memo_vu);
+				int s = max(max(s1, s2), max(s3, N-s1-s2-s3));
+				total += s*s;
+			}
+		}
+		return total;
+	}
+
+	int sim(const vector<vector<pair<EID,int>>>& T1, int E, int a1, int b1, vector<bool>& sub, vector<int>& memo)
+	{
+		if(memo[E]>=0)
+			return memo[E];
+
+		int total = sub[b1];
+		for(pair<EID,int> ic: T1[b1]) {EID id=ic.first; int c1=ic.second; if(c1 != a1) {
+			total += sim(T1, id, b1, c1, sub, memo);
+		}}
+		return memo[E] = total;
+	}
+};
+
+// 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 long long& Expected, const 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(_, TreesAnalysis().treeSimilarity(tree1, tree2));}
+int main(){
+
+CASE(0)
+	int tree1_[] = {1};
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = {1};
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = 1LL; 
+END
+CASE(1)
+	int tree1_[] = {2, 4, 1, 0};
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = {1, 4, 4, 4};
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = 111LL; 
+END
+CASE(2)
+	int tree1_[] = {1, 2, 3, 4};
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = {1, 2, 3, 4}
+;
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = 128LL; 
+END
+CASE(3)
+	int tree1_[] = {2, 3, 4, 4, 5, 8, 5, 6, 10, 8};
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = {9, 0, 1, 0, 3, 0, 5, 0, 7, 10};
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = 6306LL; 
+END
+CASE(4)
+	int tree1_[] = {222, 261, 167, 133, 174, 150, 165, 311, 208, 268, 111, 222, 154, 277, 282, 201, 46, 124, 194, 331, 4, 216, 111, 
+275, 72, 322, 137, 216, 241, 48, 72, 101, 232, 165, 151, 263, 139, 16, 122, 140, 84, 135, 314, 106, 309, 126, 102, 
+151, 208, 27, 242, 93, 83, 314, 136, 77, 82, 215, 16, 232, 286, 156, 294, 38, 67, 204, 206, 137, 174, 282, 188, 
+143, 84, 279, 236, 136, 158, 10, 65, 332, 122, 44, 329, 62, 174, 67, 102, 216, 245, 296, 287, 307, 93, 197, 169, 
+268, 266, 294, 157, 277, 95, 68, 214, 135, 211, 127, 82, 108, 212, 161, 243, 212, 207, 119, 119, 158, 97, 290, 21, 
+217, 230, 85, 171, 13, 138, 294, 304, 204, 318, 115, 70, 210, 195, 223, 37, 164, 149, 3, 164, 328, 316, 108, 330, 
+48, 38, 324, 222, 193, 50, 41, 184, 93, 148, 41, 151, 139, 106, 301, 264, 80, 249, 110, 244, 109, 212, 223, 279, 
+330, 67, 27, 301, 165, 236, 194, 3, 157, 1, 217, 311, 87, 105, 4, 286, 37, 6, 31, 111, 66, 230, 227, 244, 322, 
+196, 65, 69, 305, 112, 133, 231, 68, 153, 206, 309, 248, 329, 58, 69, 69, 328, 0, 29, 233, 243, 305, 167, 80, 65, 
+194, 190, 179, 142, 196, 324, 206, 134, 50, 272, 261, 10, 147, 329, 322, 14, 142, 169, 21, 296, 284, 241, 55, 304, 
+150, 166, 230, 167, 304, 87, 156, 156, 97, 274, 324, 196, 101, 82, 106, 260, 242, 233, 207, 305, 10, 166, 53, 18, 
+154, 233, 217, 296, 263, 168, 138, 30, 115, 135, 188, 98, 309, 292, 204, 150, 210, 332, 330, 166, 96, 70, 24, 229, 
+215, 201, 285, 40, 287, 142, 68, 133, 208, 268, 161, 310, 41, 203, 73, 275, 184, 163, 227, 89, 110, 328, 108, 112, 
+125, 164, 127, 179, 267, 221, 49, 139, 1, 84, 136, 38, 6, 70, 246, 243, 3, 188, 297};
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = {174, 262, 195, 288, 157, 278, 36, 133, 230, 273, 222, 138, 97, 23, 189, 141, 296, 55, 45, 301, 81, 199, 188, 289, 
+187, 164, 113, 58, 138, 300, 289, 282, 329, 91, 130, 178, 92, 143, 48, 81, 311, 133, 151, 286, 171, 196, 199, 80, 
+83, 121, 65, 151, 277, 136, 49, 111, 58, 36, 259, 14, 31, 9, 136, 181, 122, 324, 249, 114, 9, 37, 259, 242, 165, 
+174, 34, 36, 298, 92, 301, 237, 178, 82, 65, 295, 110, 311, 274, 235, 68, 56, 259, 180, 195, 52, 110, 68, 140, 71, 
+52, 296, 290, 115, 213, 82, 209, 209, 74, 178, 302, 131, 99, 205, 296, 309, 288, 180, 329, 71, 143, 58, 152, 273, 
+196, 7, 169, 88, 231, 331, 213, 181, 80, 249, 170, 246, 16, 127, 75, 276, 332, 174, 21, 180, 163, 78, 242, 312, 
+295, 199, 89, 142, 85, 195, 115, 119, 95, 94, 279, 290, 3, 33, 93, 284, 20, 47, 47, 78, 331, 271, 113, 179, 249, 
+331, 92, 324, 9, 71, 232, 46, 28, 289, 80, 28, 80, 134, 20, 280, 277, 48, 205, 107, 52, 320, 4, 191, 160, 182, 
+189, 227, 295, 115, 54, 195, 78, 292, 189, 273, 301, 69, 305, 36, 222, 167, 326, 106, 48, 45, 74, 61, 181, 311, 
+292, 270, 201, 34, 314, 218, 214, 92, 269, 18, 37, 151, 142, 209, 11, 227, 327, 198, 28, 272, 152, 22, 47, 143, 
+332, 253, 273, 35, 78, 130, 295, 223, 181, 329, 18, 238, 300, 186, 274, 99, 300, 322, 41, 185, 311, 288, 198, 2, 
+37, 83, 238, 133, 122, 178, 107, 106, 66, 238, 69, 90, 38, 109, 246, 278, 288, 250, 321, 269, 130, 28, 115, 122, 
+33, 185, 275, 99, 130, 99, 152, 268, 133, 249, 180, 30, 210, 201, 324, 29, 290, 143, 3, 269, 68, 106, 230, 1, 
+269, 29, 120, 259, 324, 328, 23, 243, 9, 61, 14, 118, 199, 146, 237, 14};
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = 11478648052LL; 
+END
+/*
+CASE(5)
+	int tree1_[] = ;
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = ;
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = LL; 
+END
+CASE(6)
+	int tree1_[] = ;
+	  vector <int> tree1(tree1_, tree1_+sizeof(tree1_)/sizeof(*tree1_)); 
+	int tree2_[] = ;
+	  vector <int> tree2(tree2_, tree2_+sizeof(tree2_)/sizeof(*tree2_)); 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/621-U/1C-U.cpp
Index: SRM/621-U/1C-U.cpp
==================================================================
--- SRM/621-U/1C-U.cpp
+++ SRM/621-U/1C-U.cpp
@@ -0,0 +1,192 @@
+#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;
+
+struct SaComp {
+	const int sp, *sr, srlen;
+	SaComp(int sp, const vector<int>& sr) : sp(sp), sr(&sr[0]), srlen(sr.size()) {}
+	bool operator()(int a, int b) const
+	  { return make_pair(sr[a], a+sp<srlen?sr[a+sp]:0x7fffffff)
+	         < make_pair(sr[b], b+sp<srlen?sr[b+sp]:0x7fffffff); }
+};
+
+template<typename RanIt>
+vector<int> compute_suffix_array(RanIt beg, RanIt end)
+{
+	const int N = end - beg;
+
+	vector<int> sa(N);
+	vector<int> sort_rank(beg, end);
+	for(int i=0; i<N; ++i)
+		sa[i] = i;
+
+	sort(sa.begin(), sa.end(), SaComp(0, sort_rank));
+	for(int sorted_prefix=1; sorted_prefix<N; sorted_prefix*=2)
+	{
+		SaComp cmp(sorted_prefix, sort_rank);
+		sort(sa.begin(), sa.end(), cmp);
+
+		vector<int> block_id(N);
+		for(int i=1; i<N; ++i)
+			block_id[i] = block_id[i-1] + (cmp(sa[i-1], sa[i]) ? 1 : 0);
+		for(int i=0; i<N; ++i)
+			sort_rank[sa[i]] = block_id[i];
+	}
+	return sa;
+}
+
+vector<int> inv_sa(const vector<int>& sa)
+{
+	vector<int> isa(sa.size());
+	for(int i=0; i<sa.size(); ++i)
+		isa[sa[i]] = i;
+	return isa;
+}
+
+template<typename RanIte>
+vector<int> longest_common_prefix(RanIte beg, RanIte end, const vector<int>& sa)
+{
+	const int N = sa.size();
+	vector<int> lcp(N);
+	vector<int> inv = inv_sa(sa);
+
+	int len = 0;
+	for(int i=0; i<N; ++i) {
+		int sa_idx = inv[i];
+		if( sa_idx == 0 )
+			lcp[sa_idx] = -1;
+		else {
+			for(int k=sa[sa_idx-1]; i+len<N && k+len<N && *(beg+i+len)==*(beg+k+len);)
+				++len;
+			lcp[sa_idx] = len;
+		}
+		if(len) --len;
+	}
+	return lcp;
+}
+
+class StringsNightmareAgain { public:
+	long long UniqueSubstrings(int a, int b, int c, int d, int n)
+	{
+		string S(n,'a');
+		for(int i=0; i<a; ++i) {
+			b = int((LL(b)*c+d)%n);
+			S[b] = 'b';
+		}
+		return solve(S);
+	}
+
+	LL solve(const string& S)
+	{
+		vector<int> sa = compute_suffix_array(S.begin(), S.end());
+		vector<int> lcp = longest_common_prefix(S.begin(), S.end(), sa);
+
+		for(int i=0; i+1<sa.size(); ++i)
+		{
+
+		}
+		return 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 long long& Expected, const 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(_, StringsNightmareAgain().UniqueSubstrings(a, b, c, d, n));}
+int main(){
+
+CASE(0)
+	int a = 0; 
+	int b = 0; 
+	int c = 0; 
+	int d = 0; 
+	int n = 4; 
+	long long _ = 2LL; 
+END
+CASE(1)
+	int a = 2; 
+	int b = 3; 
+	int c = 1; 
+	int d = 1; 
+	int n = 6; 
+	long long _ = 3LL; 
+END
+CASE(2)
+	int a = 4; 
+	int b = 3; 
+	int c = 1; 
+	int d = 1; 
+	int n = 6; 
+	long long _ = 3LL; 
+END
+CASE(3)
+	int a = 4; 
+	int b = 3; 
+	int c = 3; 
+	int d = 3; 
+	int n = 10; 
+	long long _ = 5LL; 
+END
+CASE(4)
+	int a = 5; 
+	int b = 3; 
+	int c = 2; 
+	int d = 3; 
+	int n = 11; 
+	long long _ = 9LL; 
+END
+CASE(5)
+	int a = 10; 
+	int b = 1000000; 
+	int c = 1000000; 
+	int d = 1; 
+	int n = 51; 
+	long long _ = 63LL; 
+END
+/*
+CASE(6)
+	int a = ; 
+	int b = ; 
+	int c = ; 
+	int d = ; 
+	int n = ; 
+	long long _ = LL; 
+END
+CASE(7)
+	int a = ; 
+	int b = ; 
+	int c = ; 
+	int d = ; 
+	int n = ; 
+	long long _ = LL; 
+END
+*/
+}
+// END CUT HERE