ADDED   SRM/526-U/2A.cpp
Index: SRM/526-U/2A.cpp
==================================================================
--- SRM/526-U/2A.cpp
+++ SRM/526-U/2A.cpp
@@ -0,0 +1,98 @@
+#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 <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class CheatingQuiz { public:
+	vector <int> howMany(string answers)
+	{
+		int N = answers.size();
+		vector<int> re;
+		int A = count(answers.begin(), answers.end(), 'A');
+		int B = count(answers.begin(), answers.end(), 'B');
+		int C = count(answers.begin(), answers.end(), 'C');
+		for(int i=0; i<N; ++i) {
+			re.push_back(!!A + !!B + !!C);
+			(answers[i]=='A' ? A : answers[i]=='B' ? B : C)--;
+		}
+		return re;
+	}
+};
+
+// 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 <int>& Expected, const vector <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(_, CheatingQuiz().howMany(answers));}
+int main(){
+
+CASE(0)
+	string answers = "AAAAA"; 
+	int __[] = {1, 1, 1, 1, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string answers = "AAABBB"; 
+	int __[] = {2, 2, 2, 1, 1, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	string answers = "CAAAAAC"; 
+	int __[] = {2, 2, 2, 2, 2, 2, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string answers = "BBCA"; 
+	int __[] = {3, 3, 2, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string answers = "BACACABCBBBBCAAAAACCCABBCAA"; 
+	int __[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, 1 };
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(5)
+	string answers = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	string answers = ; 
+	int __[] = ;
+	  vector <int> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/527-U/1A.cpp
Index: SRM/527-U/1A.cpp
==================================================================
--- SRM/527-U/1A.cpp
+++ SRM/527-U/1A.cpp
@@ -0,0 +1,110 @@
+#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 <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class P8XGraphBuilder { public:
+	int solve(vector <int> scores)
+	{
+		scores.insert(scores.begin(), 9999999);
+		const int N = scores.size();
+
+		int best = 0;
+		for(int leaves=1; leaves<N; ++leaves)
+			best = max(best, scores[1]*leaves + calc(leaves, N-leaves, scores));
+		return best;
+	}
+
+	map<pair<int,int>,int> memo;
+	int calc(int leaves, int nodes, const vector<int>& scores)
+	{
+		if( nodes == 1 )
+			return scores[leaves];
+
+		pair<int,int> key(leaves, nodes);
+		if( memo.count(key) )
+			return memo[key];
+
+		int best = 0;
+		for(int k=1; k<=leaves; ++k)
+			best = max(best, scores[k+1] + calc(leaves-k+1, nodes-1, scores));
+		return memo[key] = 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(_, P8XGraphBuilder().solve(scores));}
+int main(){
+
+CASE(0)
+	int scores_[] = {1, 3, 0};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = 8; 
+END
+CASE(1)
+	int scores_[] = {0, 0, 0, 10};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = 10; 
+END
+CASE(2)
+	int scores_[] = {1, 2, 3, 4, 5, 6};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = 12; 
+END
+CASE(3)
+	int scores_[] = {5, 0, 0};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = 15; 
+END
+CASE(4)
+	int scores_[] = {1, 3, 2, 5, 3, 7, 5};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = 20; 
+END
+CASE(5)
+int scores_[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = -1; 
+END
+CASE(6)
+	int scores_[] = {2};
+	  vector <int> scores(scores_, scores_+sizeof(scores_)/sizeof(*scores_)); 
+	int _ = 4; 
+END
+
+}
+// END CUT HERE

ADDED   SRM/527-U/1B.cpp
Index: SRM/527-U/1B.cpp
==================================================================
--- SRM/527-U/1B.cpp
+++ SRM/527-U/1B.cpp
@@ -0,0 +1,256 @@
+#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 <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+typedef int           vert;
+typedef vert          edge;
+typedef vector<edge>  edges;
+typedef vector<edges> graph;
+
+bool augment( graph& G, int v, vector<vert>& matchTo, bool visited[] )
+{
+	for(int i=0; i<G[v].size(); ++i) {
+		vert u = G[v][i];
+		if( visited[u] ) continue;
+		visited[u] = true;
+
+		if( matchTo[u]<0 || augment(G, matchTo[u], matchTo, visited) )
+			{ matchTo[v]=u, matchTo[u]=v; return true; }
+	}
+	return false;
+}
+
+template<int NV>
+int biMatch( graph& G, int L ) // [0,L):left, [L,?):right
+    // only left->right edges are used during computation
+{
+	vector<vert> matchTo(G.size(), -1);
+	int ans = 0;
+	for(vert v=0; v<L; ++v) {
+		bool visited[NV] = {};
+		if( augment(G, v, matchTo, visited) )
+			++ans;
+	}
+	return ans;
+}
+
+class P8XMatrixRecovery { public:
+	int H, W;
+	vector <string> solve(vector <string> rows, vector <string> columns)
+	{
+		H = rows.size();
+		W = rows[0].size();
+		for(int y=0; y<H; ++y)
+			for(int x=0; x<W; ++x)
+				if( rows[y][x] == '?' ) {
+					rows[y][x] = '0';
+					if( !can(rows, columns) )
+						rows[y][x] = '1';
+				}
+		return rows;
+	}
+
+	bool can(const vector<string>& rows, const vector<string>& columns)
+	{
+		graph G(W*2);
+		for(int x1=0; x1<W; ++x1) {
+			string left;
+			for(int y=0; y<H; ++y)
+				left += rows[y][x1];
+			for(int x2=0; x2<W; ++x2)
+				if( match(left, columns[x2]) ) 
+					G[x1].push_back(x2+W);
+		}
+		return biMatch<60>(G, W) == W;
+	}
+
+	bool match( const string& l, const string& r )
+	{
+		for(int i=0; i<l.size(); ++i)
+			if( l[i]!=r[i] && l[i]!='?' && r[i]!='?' )
+				return false;
+		return true;
+	}
+};
+
+// 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 <string>& Expected, const vector <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(_, P8XMatrixRecovery().solve(rows, columns));}
+int main(){
+
+CASE(0)
+	string rows_[] = {"10?"
+,"?11"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"01"
+,"10"
+,"1?"}
+;
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"101", "011" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	string rows_[] = {"0"
+,"?"
+,"1"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"0?1"};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"0", "0", "1" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	string rows_[] = {"10"
+,"01"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"10"
+,"01"};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"10", "01" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(3)
+	string rows_[] = {"??0"
+,"11?"
+,"?01"
+,"1?1"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"1???"
+,"?111"
+,"0?1?"};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"010", "110", "101", "101" };
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(4)
+	string rows_[] = {
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+	};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+		"??????????????????????????????",
+	};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+  string __[] = {"?"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+string rows_[] = {"?"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"?"};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"0"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(6)
+	string rows_[] = {"??","??"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"00","11"};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"01","01"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(7)
+	string rows_[] = {"0??", "?0?"};
+	  vector <string> rows(rows_, rows_+sizeof(rows_)/sizeof(*rows_)); 
+	string columns_[] = {"01", "00", "10"};
+	  vector <string> columns(columns_, columns_+sizeof(columns_)/sizeof(*columns_)); 
+	string __[] = {"001", "100"};
+	  vector <string> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+
+}
+// END CUT HERE

ADDED   SRM/527-U/2A.cpp
Index: SRM/527-U/2A.cpp
==================================================================
--- SRM/527-U/2A.cpp
+++ SRM/527-U/2A.cpp
@@ -0,0 +1,133 @@
+#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 <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class P8XMatrixTransformation { public:
+	string solve(vector <string> original, vector <string> target)
+	{
+		int so = 0, st = 0;
+		for(int y=0; y<original.size(); ++y) {
+			so += accumulate(original[y].begin(), original[y].end(), 0);
+			st += accumulate(target[y].begin(), target[y].end(), 0);
+		}
+		return so==st ? "YES" : "NO";
+	}
+};
+
+// 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(_, P8XMatrixTransformation().solve(original, target));}
+int main(){
+
+CASE(0)
+	string original_[] = {"01"
+,"11"};
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = {"11"
+,"10"};
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = "YES"; 
+END
+CASE(1)
+	string original_[] = {"0111"
+,"0011"};
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = {"1011"
+,"1100"};
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = "YES"; 
+END
+CASE(2)
+	string original_[] = {"0"};
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = {"1"};
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = "NO"; 
+END
+CASE(3)
+	string original_[] = {"1111"
+,"1111"
+,"0000"
+,"0000"};
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = {"1111"
+,"1111"
+,"0000"
+,"0000"};
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = "YES"; 
+END
+CASE(4)
+	string original_[] = {"0110"
+,"1001"
+,"0110"};
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = {"1111"
+,"0110"
+,"0000"};
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = "YES"; 
+END
+CASE(5)
+	string original_[] = {"0000"
+,"1111"
+,"0000"};
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = {"1111"
+,"0000"
+,"1111"};
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = "NO"; 
+END
+/*
+CASE(6)
+	string original_[] = ;
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = ;
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = ; 
+END
+CASE(7)
+	string original_[] = ;
+	  vector <string> original(original_, original_+sizeof(original_)/sizeof(*original_)); 
+	string target_[] = ;
+	  vector <string> target(target_, target_+sizeof(target_)/sizeof(*target_)); 
+	string _ = ; 
+END
+*/
+}
+// END CUT HERE

ADDED   SRM/527-U/2C.cpp
Index: SRM/527-U/2C.cpp
==================================================================
--- SRM/527-U/2C.cpp
+++ SRM/527-U/2C.cpp
@@ -0,0 +1,115 @@
+#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 <cstring>
+#ifdef __GNUC__
+#include <ext/hash_map>
+#define unordered_map __gnu_cxx::hash_map
+#else
+#include <unordered_map>
+#endif
+using namespace std;
+typedef long long LL;
+typedef complex<double> CMP;
+
+class P8XCoinChangeAnother { public:
+	vector<long long> solve(int N, long long coins_sum, long long coins_count)
+	{
+		vector<LL> result;
+		for(int i=0; i<N; ++i) {
+			LL tick = i==N-1 ? coins_sum>>i : ((1LL<<i)&coins_sum ? 1 : 0);
+			result.push_back( tick );
+			coins_count -= tick;
+		}
+		if( coins_count < 0 )
+			return vector<LL>();
+
+		for(int i=N-1; i>0; --i) {
+			if( coins_count == 0 )
+				return result;
+			else {
+				LL& me = result[i];
+				LL dec = min(me, coins_count);
+				me -= dec;
+				result[i-1] += dec*2;
+				coins_count -= dec;
+			}
+		}
+		return coins_count == 0 ? result : vector<LL>();
+	}
+};
+
+// 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(_, P8XCoinChangeAnother().solve(N, coins_sum, coins_count));}
+int main(){
+
+CASE(0)
+	int N = 2; 
+	long long coins_sum = 4LL; 
+	long long coins_count = 3LL; 
+	long long __[] = {2, 1 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(1)
+	int N = 3; 
+	long long coins_sum = 6LL; 
+	long long coins_count = 3LL; 
+	long long __[] = {0, 3, 0 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(2)
+	int N = 2; 
+	long long coins_sum = 8LL; 
+	long long coins_count = 1LL; 
+	vector<long long> _; 
+END
+CASE(3)
+	int N = 1; 
+	long long coins_sum = 10000000000LL; 
+	long long coins_count = 10000000000LL; 
+	long long __[] = {10000000000 };
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+/*
+CASE(4)
+	int N = ; 
+	long long coins_sum = LL; 
+	long long coins_count = LL; 
+	long long __[] = ;
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+CASE(5)
+	int N = ; 
+	long long coins_sum = LL; 
+	long long coins_count = LL; 
+	long long __[] = ;
+	  vector<long long> _(__, __+sizeof(__)/sizeof(*__)); 
+END
+*/
+}
+// END CUT HERE