Overview
| SHA1 Hash: | bc2785b91d796e2f738e5207256b1c4e811065dd |
|---|---|
| Date: | 2012-08-17 04:03:38 |
| User: | kinaba |
| Comment: | 552, rank 1! |
| Timelines: | family | ancestors | descendants | both | trunk |
| Downloads: | Tarball | ZIP archive |
| Other Links: | files | file ages | manifest |
Tags And Properties
- branch=trunk inherited from [9165bd3629]
- sym-trunk inherited from [9165bd3629]
Changes
Added SRM/551-U/2C.cpp version [a8ce90d2d41ecf1d]
> 1 #include <iostream> > 2 #include <sstream> > 3 #include <iomanip> > 4 #include <vector> > 5 #include <string> > 6 #include <map> > 7 #include <set> > 8 #include <algorithm> > 9 #include <numeric> > 10 #include <iterator> > 11 #include <functional> > 12 #include <complex> > 13 #include <queue> > 14 #include <stack> > 15 #include <cmath> > 16 #include <cassert> > 17 using namespace std; > 18 typedef long long LL; > 19 typedef long double LD; > 20 typedef complex<LD> CMP; > 21 > 22 static const int MODVAL = 1000000007; > 23 struct mint > 24 { > 25 int val; > 26 mint():val(0){} > 27 mint(int x):val(x%MODVAL) {} > 28 mint(size_t x):val(x%MODVAL) {} > 29 mint(LL x):val(x%MODVAL) {} > 30 }; > 31 mint& operator+=(mint& x, mint y) { return x = x.val+y.val; } > 32 mint& operator-=(mint& x, mint y) { return x = x.val-y.val+MODVAL; } > 33 mint& operator*=(mint& x, mint y) { return x = LL(x.val)*y.val; } > 34 mint operator+(mint x, mint y) { return x+=y; } > 35 mint operator-(mint x, mint y) { return x-=y; } > 36 mint operator*(mint x, mint y) { return x*=y; } > 37 > 38 class ColorfulCupcakesDivTwo { public: > 39 int countArrangements(string cupcakes) > 40 { > 41 vector<int> num(3); > 42 for(int i=0; i<cupcakes.size(); ++i) > 43 num[cupcakes[i]-'A']++; > 44 return solve(cupcakes.size(), num).val; > 45 } > 46 > 47 mint solve(int N, const vector<int>& num) > 48 { > 49 return (num[0] ? rec(0, 0, num[0]-1, num[1], num[2]) : 0) > 50 + (num[1] ? rec(1, 1, num[0], num[1]-1, num[2]) : 0) > 51 + (num[2] ? rec(2, 2, num[0], num[1], num[2]-1) : 0); > 52 } > 53 > 54 map<int, mint> memo; > 55 mint rec(int F, int P, int A, int B, int C) > 56 { > 57 if( (A+B+C) == 1 ) > 58 { > 59 if(A && F!=0 && P!=0 || B && F!=1 && P!=1 || C && F!=2 & > 60 return 1; > 61 else > 62 return 0; > 63 } > 64 > 65 int key = ((((F*3+P)*50+A)*50)+B)*50+C; > 66 if( memo.count(key) ) > 67 return memo[key]; > 68 > 69 mint sum = 0; > 70 if(A && P!=0) sum += rec(F, 0, A-1, B, C); > 71 if(B && P!=1) sum += rec(F, 1, A, B-1, C); > 72 if(C && P!=2) sum += rec(F, 2, A, B, C-1); > 73 return memo[key] = sum; > 74 } > 75 }; > 76 > 77 // BEGIN CUT HERE > 78 #include <ctime> > 79 double start_time; string timer() > 80 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 81 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 82 { os << "{ "; > 83 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 84 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 85 void verify_case(const int& Expected, const int& Received) { > 86 bool ok = (Expected == Received); > 87 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 88 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 89 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 90 #define END verify_case(_, ColorfulCupcakesDivTwo().countArrangements(cupca > 91 int main(){ > 92 > 93 CASE(0) > 94 string cupcakes = "ABAB"; > 95 int _ = 2; > 96 END > 97 CASE(1) > 98 string cupcakes = "ABABA"; > 99 int _ = 0; > 100 END > 101 CASE(2) > 102 string cupcakes = "ABC"; > 103 int _ = 6; > 104 END > 105 CASE(3) > 106 string cupcakes = "ABABABABABABABABABABABABABABABABABABABABABABABABAB"; > 107 int _ = 2; > 108 END > 109 CASE(4) > 110 string cupcakes = "BCBABBACBABABCCCCCAABBAACBBBBCBCAAA"; > 111 int _ = 741380640; > 112 END > 113 /* > 114 CASE(5) > 115 string cupcakes = ; > 116 int _ = ; > 117 END > 118 CASE(6) > 119 string cupcakes = ; > 120 int _ = ; > 121 END > 122 */ > 123 } > 124 // END CUT HERE
Added SRM/552/1A.cpp version [7020edc648386e31]
> 1 #include <iostream> > 2 #include <sstream> > 3 #include <iomanip> > 4 #include <vector> > 5 #include <string> > 6 #include <map> > 7 #include <set> > 8 #include <algorithm> > 9 #include <numeric> > 10 #include <iterator> > 11 #include <functional> > 12 #include <complex> > 13 #include <queue> > 14 #include <stack> > 15 #include <cmath> > 16 #include <cassert> > 17 using namespace std; > 18 typedef long long LL; > 19 typedef long double LD; > 20 typedef complex<LD> CMP; > 21 > 22 class FoxPaintingBalls { public: > 23 long long theMax(long long R, long long G, long long B, int N_) > 24 { > 25 LL N = N_; > 26 LL tot = N*(N+1)/2; > 27 LL t = tot/3; > 28 LL tr = tot%3; > 29 // (t,t,t+tr) > 30 > 31 LL l=0, r=(R+G+B)/tot+1; // [l,r) > 32 while( l+1 < r ) { > 33 LL c = (l+r)/2; > 34 LL rr = R-t*c; > 35 LL gg = G-t*c; > 36 LL bb = B-t*c; > 37 bool can = true; > 38 if(rr<0 || gg<0 || bb<0) > 39 can = false; > 40 else > 41 can = (rr+gg+bb >= tr*c); > 42 (can ? l : r) = c; > 43 } > 44 return l; > 45 } > 46 }; > 47 > 48 // BEGIN CUT HERE > 49 #include <ctime> > 50 double start_time; string timer() > 51 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 52 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 53 { os << "{ "; > 54 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 55 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 56 void verify_case(const long long& Expected, const long long& Received) { > 57 bool ok = (Expected == Received); > 58 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 59 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 60 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 61 #define END verify_case(_, FoxPaintingBalls().theMax(R, G, B, N));} > 62 int main(){ > 63 > 64 CASE(0) > 65 long long R = 2LL; > 66 long long G = 2LL; > 67 long long B = 2LL; > 68 int N = 3; > 69 long long _ = 1LL; > 70 END > 71 CASE(1) > 72 long long R = 1LL; > 73 long long G = 2LL; > 74 long long B = 3LL; > 75 int N = 3; > 76 long long _ = 0LL; > 77 END > 78 CASE(2) > 79 long long R = 8LL; > 80 long long G = 6LL; > 81 long long B = 6LL; > 82 int N = 4; > 83 long long _ = 2LL; > 84 END > 85 CASE(3) > 86 long long R = 7LL; > 87 long long G = 6LL; > 88 long long B = 7LL; > 89 int N = 4; > 90 long long _ = 2LL; > 91 END > 92 CASE(4) > 93 long long R = 100LL; > 94 long long G = 100LL; > 95 long long B = 100LL; > 96 int N = 4; > 97 long long _ = 30LL; > 98 END > 99 CASE(5) > 100 long long R = 19330428391852493LL; > 101 long long G = 48815737582834113LL; > 102 long long B = 11451481019198930LL; > 103 int N = 3456; > 104 long long _ = 5750952686LL; > 105 END > 106 CASE(6) > 107 long long R = 1LL; > 108 long long G = 1LL; > 109 long long B = 1LL; > 110 int N = 1; > 111 long long _ = 3LL; > 112 END > 113 CASE(7) > 114 long long R = 1LL; > 115 long long G = 1LL; > 116 long long B = 1LL; > 117 int N = 7; > 118 long long _ = -1LL; > 119 END > 120 CASE(8) > 121 long long R = 1000000000000000000LL; > 122 long long G = 1000000000000000000LL; > 123 long long B = 1000000000000000000LL; > 124 int N = 1; > 125 long long _ = 3000000000000000000LL; > 126 END > 127 } > 128 // END CUT HERE
Added SRM/552/1B.cpp version [650208ee70c7dd25]
> 1 #include <iostream> > 2 #include <sstream> > 3 #include <iomanip> > 4 #include <vector> > 5 #include <string> > 6 #include <map> > 7 #include <set> > 8 #include <algorithm> > 9 #include <numeric> > 10 #include <iterator> > 11 #include <functional> > 12 #include <complex> > 13 #include <queue> > 14 #include <stack> > 15 #include <cmath> > 16 #include <cassert> > 17 using namespace std; > 18 typedef long long LL; > 19 typedef long double LD; > 20 typedef complex<LD> CMP; > 21 > 22 class FoxAndFlowerShopDivOne { public: > 23 int theMaxFlowers(vector <string> flowers, int maxDiff) > 24 { > 25 int H = flowers.size(); > 26 int W = flowers[0].size(); > 27 vector< vector<int> > s(H+1, vector<int>(W+1)); > 28 vector< vector<int> > d(H+1, vector<int>(W+1)); > 29 for(int y=H-1; y>=0; --y) > 30 for(int x=W-1; x>=0; --x) > 31 { > 32 s[y][x] = s[y+1][x] + s[y][x+1] - s[y+1][x+1] + (flowers > 33 d[y][x] = d[y+1][x] + d[y][x+1] - d[y+1][x+1] + (flowers > 34 } > 35 > 36 int answer = -1; > 37 > 38 for(int X=1; X<W; ++X) > 39 { > 40 map<int, int> d2s_L, d2s_R; > 41 > 42 // left > 43 for(int y=0; y<H; ++y) > 44 for(int x=0; x<X; ++x) > 45 for(int yy=y+1; yy<=H; ++yy) > 46 for(int xx=x+1; xx<=X; ++xx) > 47 { > 48 int ss = s[y][x] - s[yy][x] - s[y][xx] + s[yy][x > 49 int dd = d[y][x] - d[yy][x] - d[y][xx] + d[yy][x > 50 d2s_L[dd] = max(d2s_L[dd], ss); > 51 } > 52 > 53 // right > 54 for(int y=0; y<H; ++y) > 55 for(int x=X; x<W; ++x) > 56 for(int yy=y+1; yy<=H; ++yy) > 57 for(int xx=x+1; xx<=W; ++xx) > 58 { > 59 int ss = s[y][x] - s[yy][x] - s[y][xx] + s[yy][x > 60 int dd = d[y][x] - d[yy][x] - d[y][xx] + d[yy][x > 61 d2s_R[dd] = max(d2s_R[dd], ss); > 62 } > 63 > 64 for(map<int,int>::iterator it=d2s_L.begin(); it!=d2s_L.e > 65 for(map<int,int>::iterator jt=d2s_R.begin(); jt!=d2s_R.e > 66 if(abs(it->first + jt->first) <= maxDiff) > 67 answer = max(answer, it->second + jt->se > 68 } > 69 > 70 for(int Y=1; Y<H; ++Y) > 71 { > 72 map<int, int> d2s_L, d2s_R; > 73 > 74 // left > 75 for(int y=0; y<Y; ++y) > 76 for(int x=0; x<W; ++x) > 77 for(int yy=y+1; yy<=Y; ++yy) > 78 for(int xx=x+1; xx<=W; ++xx) > 79 { > 80 int ss = s[y][x] - s[yy][x] - s[y][xx] + s[yy][x > 81 int dd = d[y][x] - d[yy][x] - d[y][xx] + d[yy][x > 82 d2s_L[dd] = max(d2s_L[dd], ss); > 83 } > 84 > 85 // right > 86 for(int y=Y; y<H; ++y) > 87 for(int x=0; x<W; ++x) > 88 for(int yy=y+1; yy<=H; ++yy) > 89 for(int xx=x+1; xx<=W; ++xx) > 90 { > 91 int ss = s[y][x] - s[yy][x] - s[y][xx] + s[yy][x > 92 int dd = d[y][x] - d[yy][x] - d[y][xx] + d[yy][x > 93 d2s_R[dd] = max(d2s_R[dd], ss); > 94 } > 95 > 96 for(map<int,int>::iterator it=d2s_L.begin(); it!=d2s_L.e > 97 for(map<int,int>::iterator jt=d2s_R.begin(); jt!=d2s_R.e > 98 if(abs(it->first + jt->first) <= maxDiff) > 99 answer = max(answer, it->second + jt->se > 100 } > 101 > 102 return answer; > 103 } > 104 }; > 105 > 106 // BEGIN CUT HERE > 107 #include <ctime> > 108 double start_time; string timer() > 109 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 110 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 111 { os << "{ "; > 112 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 113 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 114 void verify_case(const int& Expected, const int& Received) { > 115 bool ok = (Expected == Received); > 116 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 117 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 118 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 119 #define END verify_case(_, FoxAndFlowerShopDivOne().theMaxFlowers(flowers, > 120 int main(){ > 121 > 122 CASE(0) > 123 string flowers_[] = {"LLL", > 124 "PPP", > 125 "LLL"}; > 126 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 127 int maxDiff = 1; > 128 int _ = 7; > 129 END > 130 CASE(1) > 131 string flowers_[] = {"LLL", > 132 "PPP", > 133 "LLL"}; > 134 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 135 int maxDiff = 0; > 136 int _ = 6; > 137 END > 138 CASE(2) > 139 string flowers_[] = {"...", > 140 "...", > 141 "..."}; > 142 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 143 int maxDiff = 3; > 144 int _ = 0; > 145 END > 146 CASE(3) > 147 string flowers_[] = {"LLPL.LPP", > 148 "PLPPPPLL", > 149 "L.P.PLLL", > 150 "LPL.PP.L", > 151 ".LLL.P.L", > 152 "PPLP..PL"}; > 153 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 154 int maxDiff = 2; > 155 int _ = 38; > 156 END > 157 CASE(4) > 158 string flowers_[] = {"LLLLLLLLLL", > 159 "LLLLLLLLLL", > 160 "LLLLLLLLLL", > 161 "LLLLLLLLLL", > 162 "LLLLLLLLLL"}; > 163 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 164 int maxDiff = 0; > 165 int _ = -1; > 166 END > 167 CASE(5) > 168 string flowers_[] = {"LLLP..LLP.PLL.LL..LP", > 169 "L.PL.L.LLLL.LPLLPLP.", > 170 "PLL.LL.LLL..PL...L..", > 171 ".LPPP.PPPLLLLPLP..PP", > 172 "LP.P.PPL.L...P.L.LLL", > 173 "L..LPLPP.PP...PPPL..", > 174 "PP.PLLL.LL...LP..LP.", > 175 "PL...P.PPPL..PLP.L..", > 176 "P.PPPLPLP.LL.L.LLLPL", > 177 "PLLPLLP.LLL.P..P.LPL", > 178 "..LLLPLPPPLP.P.LP.LL", > 179 "..LP..L..LLPPP.LL.LP", > 180 "LPLL.PLLPPLP...LL..P", > 181 "LL.....PLL.PLL.P....", > 182 "LLL...LPPPPL.PL...PP", > 183 ".PLPLLLLP.LPP...L...", > 184 "LL...L.LL.LLLPLPPPP.", > 185 "PLPLLLL..LP.LLPLLLL.", > 186 "PP.PLL..L..LLLPPL..P", > 187 ".LLPL.P.PP.P.L.PLPLL"}; > 188 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 189 int maxDiff = 9; > 190 int _ = 208; > 191 END > 192 CASE(6) > 193 string flowers_[] = {"L","P"}; > 194 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 195 int maxDiff = 0; > 196 int _ = 2; > 197 END > 198 CASE(7) > 199 string flowers_[] = {"LLLP..LLP.PLL.LL..LPPLL.LL..LP", > 200 "L.PL.L.LLLL.LPLLPLP.PLL.LL..LP", > 201 "PLL.LL.LLL..PL...L..PLL.LL..LP", > 202 ".LPPP.PPPLLLLPLP..PPPLL.LL..LP", > 203 "LP.P.PPL.L...P.L.LLLPLL.LL..LP", > 204 "L..LPLPP.PP...PPPL..PLL.LL..LP", > 205 "PP.PLLL.LL...LP..LP.PLL.LL..LP", > 206 "PL...P.PPPL..PLP.L..PLL.LL..LP", > 207 "P.PPPLPLP.LL.L.LLLPLPLL.LL..LP", > 208 "PLLPLLP.LLL.P..P.LPLPLL.LL..LP", > 209 "..LLLPLPPPLP.P.LP.LLPLL.LL..LP", > 210 "..LP..L..LLPPP.LL.LPPLL.LL..LP", > 211 "LPLL.PLLPPLP...LL..PPLL.LL..LP", > 212 ".LPPP.PPPLLLLPLP..PPPLL.LL..LP", > 213 "LP.P.PPL.L...P.L.LLLPLL.LL..LP", > 214 "L..LPLPP.PP...PPPL..PLL.LL..LP", > 215 "PP.PLLL.LL...LP..LP.PLL.LL..LP", > 216 "PL...P.PPPL..PLP.L..PLL.LL..LP", > 217 "P.PPPLPLP.LL.L.LLLPLPLL.LL..LP", > 218 "PLLPLLP.LLL.P..P.LPLPLL.LL..LP", > 219 "..LLLPLPPPLP.P.LP.LLPLL.LL..LP", > 220 "..LP..L..LLPPP.LL.LPPLL.LL..LP", > 221 "LPLL.PLLPPLP...LL..PPLL.LL..LP", > 222 "LL.....PLL.PLL.P....PLL.LL..LP", > 223 "LLL...LPPPPL.PL...PPPLL.LL..LP", > 224 ".PLPLLLLP.LPP...L...PLL.LL..LP", > 225 "LL...L.LL.LLLPLPPPP.PLL.LL..LP", > 226 "PLPLLLL..LP.LLPLLLL.PLL.LL..LP", > 227 "PP.PLL..L..LLLPPL..PPLL.LL..LP", > 228 ".LLPL.P.PP.P.L.PLPLLPLL.LL..LP"}; > 229 vector <string> flowers(flowers_, flowers_+sizeof(flowers_)/sizeof(*fl > 230 int maxDiff = 0; > 231 int _ = -1; > 232 END > 233 } > 234 // END CUT HERE
Added SRM/552/1C.cpp version [cbbb9cbac02277e4]
> 1 #include <iostream> > 2 #include <sstream> > 3 #include <iomanip> > 4 #include <vector> > 5 #include <string> > 6 #include <map> > 7 #include <set> > 8 #include <algorithm> > 9 #include <numeric> > 10 #include <iterator> > 11 #include <functional> > 12 #include <complex> > 13 #include <queue> > 14 #include <stack> > 15 #include <cmath> > 16 #include <cassert> > 17 using namespace std; > 18 typedef long long LL; > 19 typedef long double LD; > 20 typedef complex<LD> CMP; > 21 > 22 class HolyNumbers { public: > 23 vector<LL> erat(int N) > 24 { > 25 vector<LL> ps; > 26 vector<bool> is_prime(N+1, true); > 27 for(int p=2; p<=N; ++p) > 28 if(is_prime[p]) { > 29 ps.push_back(p); > 30 for(int q=p+p; q<=N; q+=p) > 31 is_prime[q] = false; > 32 } > 33 return ps; > 34 } > 35 > 36 long long count(long long upTo, int maximalPrime) > 37 { > 38 vector<LL> ps = erat(maximalPrime); > 39 return naive(ps, 0, upTo); > 40 } > 41 > 42 LL naive(const vector<LL>& ps, int i, LL upto) > 43 { > 44 if( i==ps.size() || upto<ps[i] ) > 45 return 1; > 46 > 47 if( upto < ps[i]*ps[i] ) > 48 { > 49 int k = upper_bound(ps.begin()+i, ps.end(), upto) - ps.b > 50 return (k-i)+1; > 51 } > 52 LL sum = naive(ps, i+1, upto); > 53 for(LL p=ps[i], pk=p; pk<=upto; pk*=p*p) > 54 sum += naive(ps, i+1, upto/pk); > 55 return sum; > 56 } > 57 }; > 58 > 59 // BEGIN CUT HERE > 60 #include <ctime> > 61 double start_time; string timer() > 62 { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) > 63 template<typename T> ostream& operator<<(ostream& os, const vector<T>& v) > 64 { os << "{ "; > 65 for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it) > 66 os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return > 67 void verify_case(const long long& Expected, const long long& Received) { > 68 bool ok = (Expected == Received); > 69 if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() > 70 cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' > 71 #define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock( > 72 #define END verify_case(_, HolyNumbers().count(upTo, maximalPrime));} > 73 int main(){ > 74 > 75 CASE(0) > 76 long long upTo = 10LL; > 77 int maximalPrime = 100; > 78 long long _ = 8LL; > 79 END > 80 CASE(1) > 81 long long upTo = 10LL; > 82 int maximalPrime = 3; > 83 long long _ = 5LL; > 84 END > 85 CASE(2) > 86 long long upTo = 123LL; > 87 int maximalPrime = 12; > 88 long long _ = 32LL; > 89 END > 90 CASE(3) > 91 long long upTo = 123LL; > 92 int maximalPrime = 456; > 93 long long _ = 88LL; > 94 END > 95 CASE(4) > 96 long long upTo = 123456789LL; > 97 int maximalPrime = 12345; > 98 long long _ = 25994500LL; > 99 END > 100 CASE(5) > 101 long long upTo = 10000000000LL; > 102 int maximalPrime = 1000000; > 103 long long _ = -1LL; > 104 END > 105 CASE(6) > 106 long long upTo = 10000000000LL; > 107 int maximalPrime = 100; > 108 long long _ = -1LL; > 109 END > 110 } > 111 // END CUT HERE