• branch=trunk inherited from [9165bd3629]
• sym-trunk inherited from [9165bd3629]

Added SRM/582-U/1A.cpp version [1612b58278693269]

            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<double> CMP;
           21  +
           22  +class SpaceWarDiv1 { public:
           23  + long long minimalFatigue(vector <int> magicalGirlStrength, vector <int> enemyStrength, vector<long long> enemyCount)
           24  + {
           25  +  int M = *max_element(magicalGirlStrength.begin(), magicalGirlStrength.end());
           26  +  int E = *max_element(enemyStrength.begin(), enemyStrength.end());
           27  +  if(M<E)
           28  +   return -1;
           29  +  sort(magicalGirlStrength.rbegin(), magicalGirlStrength.rend());
           30  +  vector< pair<int,LL> > e;
           31  +  for(int i=0; i<enemyStrength.size(); ++i)
           32  +   e.push_back(make_pair(enemyStrength[i], enemyCount[i]));
           33  +  sort(e.rbegin(), e.rend());
           34  +
           35  +  LL L=0, R=accumulate(enemyCount.begin(), enemyCount.end(), 0LL); // (L,R)
           36  +  while(R-L>1) {
           37  +   LL C = (L+R)/2;
           38  +   (possible(magicalGirlStrength, e, C) ? R : L) = C;
           39  +  }
           40  +  return R;
           41  + }
           42  +
           43  + bool possible(const vector<int>& m, const vector<pair<int,LL> >& e, LL F)
           44  + {
           45  +  int ei = 0;
           46  +  LL  eC = e[ei].second;
           47  +  for(int i=0; i<m.size() && ei<e.size(); ++i)
           48  +  {
           49  +   if(e[ei].first > m[i])
           50  +    return false;
           51  +
           52  +   for(LL p = F; p; ) {
           53  +    if(eC > p) {
           54  +     eC -= p;
           55  +     p = 0;
           56  +    }
           57  +    else {
           58  +     ++ei;
           59  +     if(ei == e.size())
           60  +      return true;
           61  +     p -= eC;
           62  +     eC = e[ei].second;
           63  +    }
           64  +   }
           65  +  }
           66  +  return (ei == e.size());
           67  + }
           68  +};
           69  +
           70  +// BEGIN CUT HERE
           71  +#include <ctime>
           72  +double start_time; string timer()
           73  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
           74  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
           75  + { os << "{ ";
           76  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
           77  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
           78  +void verify_case(const long long& Expected, const long long& Received) {
           79  + bool ok = (Expected == Received);
           80  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
           81  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
           82  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
           83  +#define END  verify_case(_, SpaceWarDiv1().minimalFatigue(magicalGirlStrength, enemyStrength, enemyCount));}
           84  +int main(){
           85  +
           86  +CASE(0)
           87  + int magicalGirlStrength_[] = {2, 3, 5};
           88  +   vector <int> magicalGirlStrength(magicalGirlStrength_, magicalGirlStrength_+sizeof(magicalGirlStrength_)/sizeof(*magicalGirlStrength_));
           89  + int enemyStrength_[] = {1, 3, 4};
           90  +   vector <int> enemyStrength(enemyStrength_, enemyStrength_+sizeof(enemyStrength_)/sizeof(*enemyStrength_));
           91  + long long enemyCount_[] = {2, 9, 4};
           92  +   vector<long long> enemyCount(enemyCount_, enemyCount_+sizeof(enemyCount_)/sizeof(*enemyCount_));
           93  + long long _ = 7LL;
           94  +END
           95  +CASE(1)
           96  + int magicalGirlStrength_[] = {2, 3, 5};
           97  +   vector <int> magicalGirlStrength(magicalGirlStrength_, magicalGirlStrength_+sizeof(magicalGirlStrength_)/sizeof(*magicalGirlStrength_));
           98  + int enemyStrength_[] = {1, 1, 2};
           99  +   vector <int> enemyStrength(enemyStrength_, enemyStrength_+sizeof(enemyStrength_)/sizeof(*enemyStrength_));
          100  + long long enemyCount_[] = {2, 9, 4};
          101  +   vector<long long> enemyCount(enemyCount_, enemyCount_+sizeof(enemyCount_)/sizeof(*enemyCount_));
          102  + long long _ = 5LL;
          103  +END
          104  +CASE(2)
          105  + int magicalGirlStrength_[] = {14, 6, 22};
          106  +   vector <int> magicalGirlStrength(magicalGirlStrength_, magicalGirlStrength_+sizeof(magicalGirlStrength_)/sizeof(*magicalGirlStrength_));
          107  + int enemyStrength_[] = {8, 33};
          108  +   vector <int> enemyStrength(enemyStrength_, enemyStrength_+sizeof(enemyStrength_)/sizeof(*enemyStrength_));
          109  + long long enemyCount_[] = {9, 1};
          110  +   vector<long long> enemyCount(enemyCount_, enemyCount_+sizeof(enemyCount_)/sizeof(*enemyCount_));
          111  + long long _ = -1LL;
          112  +END
          113  +CASE(3)
          114  + int magicalGirlStrength_[] = {869, 249, 599, 144, 929, 748, 665, 37, 313, 99, 33, 437, 308, 137, 665, 834, 955, 958, 613, 417};
          115  +   vector <int> magicalGirlStrength(magicalGirlStrength_, magicalGirlStrength_+sizeof(magicalGirlStrength_)/sizeof(*magicalGirlStrength_));
          116  + int enemyStrength_[] = {789, 57, 684, 741, 128, 794, 542, 367, 937, 739, 568, 872, 127, 261, 103, 763, 864, 360, 618, 307};
          117  +   vector <int> enemyStrength(enemyStrength_, enemyStrength_+sizeof(enemyStrength_)/sizeof(*enemyStrength_));
          118  + long long enemyCount_[] = {20626770196420, 45538527263992, 52807114957507, 17931716090785, 65032910980630, 88711853198687, 26353250637092,
          119  + 61272534748707, 89294362230771, 52058590967576, 60568594469453, 23772707032338, 43019142889727, 39566072849912,
          120  + 78870845257173, 68135668032761, 36844201017584, 10133804676521, 6275847412927, 37492167783296};
          121  +   vector<long long> enemyCount(enemyCount_, enemyCount_+sizeof(enemyCount_)/sizeof(*enemyCount_));
          122  + long long _ = 75030497287405LL;
          123  +END
          124  +CASE(4)
          125  +int magicalGirlStrength_[] = {66,16,15,85,98,82,100,21,87,21,63,48,22,82,49,91,69,85,82,100,70,40,77,53,36,8,54,26,35,7,36,74,36,70,10,30,89,14,14,64,89,87,68,40,16,46,28,75,43,10};
          126  +   vector <int> magicalGirlStrength(magicalGirlStrength_, magicalGirlStrength_+sizeof(magicalGirlStrength_)/sizeof(*magicalGirlStrength_));
          127  +   int enemyStrength_[] = {1};
          128  +   vector <int> enemyStrength(enemyStrength_, enemyStrength_+sizeof(enemyStrength_)/sizeof(*enemyStrength_));
          129  +   long long enemyCount_[] = {100000000000LL};
          130  +   vector<long long> enemyCount(enemyCount_, enemyCount_+sizeof(enemyCount_)/sizeof(*enemyCount_));
          131  + long long _ = -1LL;
          132  +END
          133  +/*
          134  +CASE(5)
          135  + int magicalGirlStrength_[] = ;
          136  +   vector <int> magicalGirlStrength(magicalGirlStrength_, magicalGirlStrength_+sizeof(magicalGirlStrength_)/sizeof(*magicalGirlStrength_));
          137  + int enemyStrength_[] = ;
          138  +   vector <int> enemyStrength(enemyStrength_, enemyStrength_+sizeof(enemyStrength_)/sizeof(*enemyStrength_));
          139  + long long enemyCount_[] = ;
          140  +   vector<long long> enemyCount(enemyCount_, enemyCount_+sizeof(enemyCount_)/sizeof(*enemyCount_));
          141  + long long _ = LL;
          142  +END
          143  + */
          144  +}
          145  +// END CUT HERE

Added SRM/582-U/1B-U.cpp version [6dcf84ee0fbfd682]

            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<double> CMP;
           21  +
           22  +static const unsigned MODVAL = 1000000009;
           23  +struct mint
           24  +{
           25  + unsigned val;
           26  + mint():val(0){}
           27  + mint(int      x):val(x%MODVAL) {}
           28  + mint(unsigned 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  +mint POW(mint x, LL e) { mint v=1; for(;e;x*=x,e>>=1) if(e&1) v*=x; return v; }
           39  +mint& operator/=(mint& x, mint y) { return x *= POW(y, MODVAL-2); }
           40  +mint operator/(mint x, mint y) { return x/=y; }
           41  +
           42  +vector<mint> FAC_(1,1);
           43  +mint FAC(LL n) { while( FAC_.size()<=n ) FAC_.push_back( FAC_.back()*FAC_.size() ); return FAC_[n]; }
           44  +
           45  +mint P(LL n, LL k) {
           46  + return k<0 || n<k ? 0 : FAC(n) / FAC(n-k);
           47  +}
           48  +
           49  +// Tested: SRM 468 Lv2
           50  +template<typename T>
           51  +struct DP3x
           52  +{
           53  + int N1, N2, N3;
           54  + vector<T> data;
           55  + DP3x(int, int N2, int N3, const T& t = T())
           56  +  : N1(2), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T) < (1<<26)); }
           57  + T& operator()(int i1, int i2, int i3)
           58  +  { i1&=1; return data[ ((i1*N2)+i2)*N3+i3 ]; }
           59  + void swap(DP3x& rhs)
           60  +  { data.swap(rhs.data); }
           61  +};
           62  +
           63  +template<typename T>
           64  +struct DP3
           65  +{
           66  + int N1, N2, N3;
           67  + vector<T> data;
           68  + DP3(int N1, int N2, int N3, const T& t = T())
           69  +  : N1(N1), N2(N2), N3(N3), data(N1*N2*N3, t) { assert(data.size()*sizeof(T)<(1<<26)); }
           70  + T& operator()(int i1, int i2, int i3)
           71  +  { return data[ ((i1*N2)+i2)*N3+i3 ]; }
           72  + void swap(DP3& rhs)
           73  +  { data.swap(rhs.data); }
           74  +};
           75  +
           76  +class ColorfulBuilding { public:
           77  + int count(vector <string> color1, vector <string> color2, int L)
           78  + {
           79  +  string C1 = accumulate(color1.begin(), color1.end(), string());
           80  +  string C2 = accumulate(color2.begin(), color2.end(), string());
           81  +  int N = C1.size();
           82  +  vector<int> C;
           83  +  for(int i=0; i<N; ++i)
           84  +   C.push_back(to_i(C1[i])*52 + to_i(C2[i]));
           85  +  return solve(C, L).val;
           86  + }
           87  +
           88  + static int to_i(char c)
           89  + {
           90  +  return ('A'<=c && c<='Z' ? c-'A' : c-'a'+26);
           91  + }
           92  +
           93  + mint solve(vector<int>& C, int L)
           94  + {
           95  +  int N = C.size();
           96  +
           97  +  DP3x<mint> dp(L+1, N, N+1);
           98  +  for(int c=1; c<=L; ++c)
           99  +  {
          100  +   for(int x=0; x<N; ++x)
          101  +   {
          102  +    dp(c,x,1) = (c==1 ? 1 : 0);
          103  +    for(int i=2; i<=x+1; ++i)
          104  +    {
          105  +     mint sum = 0;
          106  +     for(int y=0; y<x; ++y) {
          107  +      int cc = (C[x]==C[y] ? c : c-1);
          108  +      for(int k=1; k<=y+1 && k<=i-1; ++k)
          109  +       sum += dp(cc,y,k) * P(y+1-k, i-1-k);
          110  +     }
          111  +     dp(c,x,i) = sum;
          112  +    }
          113  +   }
          114  +  }
          115  +
          116  +  mint ans = 0;
          117  +  for(int i=1; i<=N; ++i)
          118  +   ans += dp(L, N-1, i) * P(N-i, N-i);
          119  +  return ans;
          120  + }
          121  +};
          122  +
          123  +// BEGIN CUT HERE
          124  +#include <ctime>
          125  +double start_time; string timer()
          126  + { ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
          127  +template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
          128  + { os << "{ ";
          129  +   for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
          130  +   os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
          131  +void verify_case(const int& Expected, const int& Received) {
          132  + bool ok = (Expected == Received);
          133  + if(ok) cerr << "PASSED" << timer() << endl;  else { cerr << "FAILED" << timer() << endl;
          134  + cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
          135  +#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
          136  +#define END  verify_case(_, ColorfulBuilding().count(color1, color2, L));}
          137  +int main(){
          138  +
          139  +CASE(0)
          140  + string color1_[] = {"aaba"};
          141  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          142  + string color2_[] = {"aaaa"};
          143  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          144  + int L = 3;
          145  + int _ = 6;
          146  +END
          147  +CASE(1)
          148  + string color1_[] = {"aaba"};
          149  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          150  + string color2_[] = {"aaba"};
          151  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          152  + int L = 4;
          153  + int _ = 0;
          154  +END
          155  +CASE(2)
          156  + string color1_[] = {"ab", "ba", "a", "aab"};
          157  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          158  + string color2_[] = {"bb", "ba", "a", "aba"};
          159  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          160  + int L = 5;
          161  + int _ = 432;
          162  +END
          163  +CASE(3)
          164  + string color1_[] = {"xxxxxxxxxxxxxxxxxxxx",
          165  + "xxxxxxxxxxxxxxxxxxxx",
          166  + "xxOOOOOOOOOOOOOOOOxx",
          167  + "xxOOOOOOOOOOOOOOOOxx",
          168  + "xxOOxxxxxxxxxxxxxxxx",
          169  + "xxOOxxxxxxxxxxxxxxxx",
          170  + "xxOOxxxxxxxxxxxxxxxx",
          171  + "xxOOxxxxxxxxxxxxxxxx",
          172  + "xxOOxxxxxxxxxxxxxxxx",
          173  + "xxOOxxxxxxxxxxxxxxxx",
          174  + "xxOOxxxxxxxxxxxxxxxx",
          175  + "xxOOOOOOOOOOOOOOOOxx",
          176  + "xxOOOOOOOOOOOOOOOOxx",
          177  + "xxxxxxxxxxxxxxxxOOxx",
          178  + "xxxxxxxxxxxxxxxxOOxx",
          179  + "xxxxxxxxxxxxxxxxOOxx",
          180  + "xxxxxxxxxxxxxxxxOOxx",
          181  + "xxxxxxxxxxxxxxxxOOxx",
          182  + "xxxxxxxxxxxxxxxxOOxx",
          183  + "xxxxxxxxxxxxxxxxOOxx",
          184  + "xxOOOOOOOOOOOOOOOOxx",
          185  + "xxOOOOOOOOOOOOOOOOxx",
          186  + "xxxxxxxxxxxxxxxxxxxx",
          187  + "xxxxxxxxxxxxxxxxxxxx"};
          188  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          189  + string color2_[] = {"xxxxxxxxxxxxxxxxxxxx",
          190  + "xxxxxxxxxxxxxxxxxxxx",
          191  + "xxOOOOOOOOOOOOOOOOxx",
          192  + "xxOOOOOOOOOOOOOOOOxx",
          193  + "xxOOxxxxxxxxxxxxOOxx",
          194  + "xxOOxxxxxxxxxxxxOOxx",
          195  + "xxOOxxxxxxxxxxxxOOxx",
          196  + "xxOOxxxxxxxxxxxxOOxx",
          197  + "xxOOxxxxxxxxxxxxOOxx",
          198  + "xxOOxxxxxxxxxxxxOOxx",
          199  + "xxOOxxxxxxxxxxxxOOxx",
          200  + "xxOOOOOOOOOOOOOOOOxx",
          201  + "xxOOOOOOOOOOOOOOOOxx",
          202  + "xxOOxxxxxxxxxxxxOOxx",
          203  + "xxOOxxxxxxxxxxxxOOxx",
          204  + "xxOOxxxxxxxxxxxxOOxx",
          205  + "xxOOxxxxxxxxxxxxOOxx",
          206  + "xxOOxxxxxxxxxxxxOOxx",
          207  + "xxOOxxxxxxxxxxxxOOxx",
          208  + "xxOOxxxxxxxxxxxxOOxx",
          209  + "xxOOOOOOOOOOOOOOOOxx",
          210  + "xxOOOOOOOOOOOOOOOOxx",
          211  + "xxxxxxxxxxxxxxxxxxxx",
          212  + "xxxxxxxxxxxxxxxxxxxx"};
          213  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          214  + int L = 58;
          215  + int _ = 619787617;
          216  +END
          217  +CASE(4)
          218  + string color1_[] = {"SJXcabKTWeUXhwxGixFepQaQlFxrAedNAtVP",
          219  + "gorBIkcTlOFbLDbFeElYAyAqszQdMbpxSRdE",
          220  + "SQVHPehlNtesbJDflyGxMqvgzjXisRnqDcQO",
          221  + "pIAEBwbmpPWCooQAujbGXFGLvXxTmExLARkf",
          222  + "AFnWyWKVObfxDGCjTxdZaObgwdxlPKtIxaAd",
          223  + "uznMpJVNjAofbHJjOrZeSHgSagOCUMGbvkVR",
          224  + "LBRrDbTAyKfVnedKiRfzgRzECpcsziqaTwdo",
          225  + "JrJHvsEVVGDkNVGqLbpxyLDPloBuNDQKnReI",
          226  + "SSYpbjKHSCnQhuyYrVauWDHDyhAoGyecrZMv",
          227  + "UdetQfWEUWHHuAxRSdkJOOJSixKpQXpCFZHO",
          228  + "KXVsQbuQtIgsULOMsTvPFNUqkBldMTLCipYK",
          229  + "hoXConjnDWQkZVtyZlwSedvdVrNWqQhGUClQ",
          230  + "TpsvvyoXsXmQpBAGGVDrXCkodoRHQZmpoQDW",
          231  + "csiJspzTqeFBRmPgeEtTAzfrfCGlTZqcPuyO",
          232  + "vsPDVBJVaJmUAtDdcsKoUkPEbDmAwtZKwjjP",
          233  + "MOfoMhMiKIvGQoeIJXHzyClWRtRuKXMqxUAF",
          234  + "KyyUCkRBjsYvmPFFEGBqqVhIUdtvIyyLacfu",
          235  + "BfuwfSajSlcuTzhMufHSQLudvGEGlyHsEmBD",
          236  + "PLpIXZkdyXveTMfSvqnDGKWOZrTBMUIlZrqF",
          237  + "dzVMCqrSLbanRJTYpDJNHAOLPSzmvSEPQJYm",
          238  + "rAjRkrSjouJyFaCSPPLYSzqDmMoADyWAbobJ",
          239  + "eOCBrJNoyFnGpXpxiExXcoOHnVsaEPXhPfLe",
          240  + "XMjRksnxWssPEINhdhbiLBSYpCLtwNshFjXS",
          241  + "HnnDeUAbuswsgsYQuAaXySLkFYUwFXwYTreM",
          242  + "uqLnwOEGbwZZDgAAWEdLRZxFlogDmlhjhgHM",
          243  + "NcfaQsgPQfirkYDRFrLQpySmBGfRHumKULZf",
          244  + "mOpmmgclsxRzXskEywfryqCRyATNoJwnlHiD",
          245  + "AnoKoKAjrasttjNlHCROnvTJMhEHlVPVoVMo",
          246  + "yegLyIuRkkENFAjwzDoPLKjgUHHEkfzYDIpo",
          247  + "EcxRGGfuaBXUFXkSxctJWOLmmVbvoMkWtTvV",
          248  + "nBMkOBHgaltEVzfyGxseGhmBscfGIbxFbqRn",
          249  + "GvkEcLtqdOofGtsbWDafVMbNdJxsffKDzSiR",
          250  + "jhZQUVzTzalrZcebvyqPWtOUUyniBKTWdyLi",
          251  + "ODJLQPMdjDdTlxrfGsNmBfeGYjzeXApqKDhJ",
          252  + "vlJkWMzdVQujKdLViQClOrJXMTBkuZEasFgg",
          253  + "FAsbuzrLVIgaryqXBfuBRAbReleXSSgEKSvt"};
          254  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          255  + string color2_[] = {"XAhlUHtfjOpOlQlowWppQcodMGUiqoLobxnD",
          256  + "IDzGlKrHiVGdBjZxIcoxjwagbWieKvUwZrjg",
          257  + "SkpkTVeIFeoNQzUUgmYAYskKONNZdgXxSiWd",
          258  + "rXBGhTmqnvxkmqiutoDzPusDiOUggEFXGCzm",
          259  + "fzrxVuTbFXunGbeEavjshmrIRlDorTuISCxn",
          260  + "LsvIaxTkOBjcskiekmrKNNFEXqnfMNXLWqqu",
          261  + "ekzxGIlbJPVEQPYAbTuMtZKsCiubDXDiBVzU",
          262  + "hZuOCJxvBOYENGSFcUiKKAKfCdebutVmnyvB",
          263  + "UveNkKRQmHnedrROQOpHJfrHjwcNLUShlDbn",
          264  + "ptUkvbaGDryHRkYfHKLkSgVpjWCEcgazyxGK",
          265  + "nVPYEqTTJsRPjzjfdOiULhnZPFeNcnbXaQlk",
          266  + "IPXBXRhMQIkxpygsgbcRfMuvIcuzUPPHGOWX",
          267  + "yWWlNyEyqZSIOXBFAybIuFpVqpvmKRaRFrAE",
          268  + "EvBJVtHvKhjrFcmtpdBbFTdTVtXXZQKAglKT",
          269  + "bCVjHzUvyINFkxXageZQMzCyNhcifACdJVDh",
          270  + "lZITYcDSeIbLweyFtoMAfOQyBNupKlhcNpgo",
          271  + "BduslNrJdWOUukYFFidEkMFaghfofpxVgvJd",
          272  + "YrJpDZKqdjEPzdLsOQEdkcrBfNHPemXHokCW",
          273  + "GjeUKSGjDlgKTyUGNrMQbBLxRUcgrWpkAwOD",
          274  + "wgxTcswqdJHaDugNIRMvrhBsdDaJAssVbSRW",
          275  + "qmVmqFEpvgGioMXDSFqEoQcDOAaUoGPEovSO",
          276  + "KrukPlpfOhawaovCfteTSCIdLMrtImVtiMyQ",
          277  + "ykwmxHsKMFzFHwcbyyedLvhZPnaNGqJMMCxd",
          278  + "HUNYCXjNLQIFCLLGpCXHBCHLTxLynBxnHFbx",
          279  + "uwjzbNbJepVFgMPUXVirxYHzExquBEtPmKju",
          280  + "xXAxAbJePyUsVHeLytDvAxBGMRtnvCEiZZqe",
          281  + "xMkQoIVxWPXPgaOYmDjTOXiMImVdzojERNxS",
          282  + "dwICFwMAmdOIUxyAdXdshasnzwyhfnVWVqZJ",
          283  + "etypXNVvSTEQvriGBZdSGmDEHhvpSqkFklCS",
          284  + "YkxpFBCRYUueRcKaJUXVdaMoYMYEooPQVMOr",
          285  + "DTrexDqclZNKdPuTRFHualJSFziCLPCZjpxo",
          286  + "TfEijcAsSJPikkmBSbXMqYHAhPTcpcKVSkIX",
          287  + "xKXHYPYMJxFpSbxltDKYuRiTkOLxpQKnXZPs",
          288  + "YFYuvuYHfpFJcrLNIdlNfBxRnWdppsdalBkx",
          289  + "NFTysBvNFjejdnlhRTclbcfGipNCxpFEOriY",
          290  + "thkgVflJYmbUYbIlafNUMGePQWiZyYzYXvUR"}
          291  +;
          292  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          293  + int L = 1200;
          294  + int _ = 396065426;
          295  +END
          296  +/*
          297  +CASE(5)
          298  + string color1_[] = ;
          299  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          300  + string color2_[] = ;
          301  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          302  + int L = ;
          303  + int _ = ;
          304  +END
          305  +CASE(6)
          306  + string color1_[] = ;
          307  +   vector <string> color1(color1_, color1_+sizeof(color1_)/sizeof(*color1_));
          308  + string color2_[] = ;
          309  +   vector <string> color2(color2_, color2_+sizeof(color2_)/sizeof(*color2_));
          310  + int L = ;
          311  + int _ = ;
          312  +END
          313  +*/
          314  +}
          315  +// END CUT HERE