SSL regress-80981.js   Interaktion und
PortierbarkeitJAVA

// |reftest| slow
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 *
 * Date: 19 Nov 2001
 * SUMMARY: Regression test for bug 80981.
 * See http://bugzilla.mozilla.org/show_bug.cgi?id=80981
 * "Need extended jump bytecode to avoid "script too large" errors, etc."
 *
 * Before this bug was fixed, the script below caused a run-time error because
 * its switch statement was too big. After the fix, SpiderMonkey should compile
 * this script just fine. The same fix has not been made in Rhino, however,
 * so it will continue to error there...
 *
 * If you ever run this test against an old SpiderMonkey shell to see the bug,
 * you should run it interactively: i.e. launch the JS shell manually, and load
 * the test manually. Do not run it via the test driver jsDriverl.pl. Why? -
 * before the fix for bug 97646, the JS shell would error on this script, but
 * would NOT give non-0 exit code. As a result, the test driver couldn't detect
 * the error (it looks for non-0 exit codes).
 *
 */
//-----------------------------------------------------------------------------
var i2 = 3011;
var n = new Array (i2);
var err_num = 0;
var i = 0;
var j = 0;
var k = 0;


//-----------------------------------------------------------------------------
test();
//-----------------------------------------------------------------------------


function test()
{
  b ();
  b4 ();
  print('Number of errors = ' + err_num);
}


function b()
{
  b4 ();
  b_after ();

  for (i=0; i<i2; i++) {n[i] = 0;}
  i = 0;
 
  while (k++ <= i2)
  {
    switch (j = (k*73)%i2)
    {
    case 0: if (n[0]++ > 0) check ('a string 0'); break;
    case 1: if (n[1]++ > 0) check ('a string 1'); break;
    case 2: if (n[2]++ > 0) check ('a string 2'); break;
    case 3: if (n[3]++ > 0) check ('a string 3'); break;
    case 4: if (n[4]++ > 0) check ('a string 4'); break;
    case 5: if (n[5]++ > 0) check ('a string 5'); break;
    case 6: if (n[6]++ > 0) check ('a string 6'); break;
    case 7: if (n[7]++ > 0) check ('a string 7'); break;
    case 8: if (n[8]++ > 0) check ('a string 8'); break;
    case 9: if (n[9]++ > 0) check ('a string 9'); break;
    case 10: if (n[10]++ > 0) check ('a string 10'); break;
    case 11: if (n[11]++ > 0) check ('a string 11'); break;
    case 12: if (n[12]++ > 0) check ('a string 12'); break;
    case 13: if (n[13]++ > 0) check ('a string 13'); break;
    case 14: if (n[14]++ > 0) check ('a string 14'); break;
    case 15: if (n[15]++ > 0) check ('a string 15'); break;
    case 16: if (n[16]++ > 0) check ('a string 16'); break;
    case 17: if (n[17]++ > 0) check ('a string 17'); break;
    case 18: if (n[18]++ > 0) check ('a string 18'); break;
    case 19: if (n[19]++ > 0) check ('a string 19'); break;
    case 20: if (n[20]++ > 0) check ('a string 20'); break;
    case 21: if (n[21]++ > 0) check ('a string 21'); break;
    case 22: if (n[22]++ > 0) check ('a string 22'); break;
    case 23: if (n[23]++ > 0) check ('a string 23'); break;
    case 24: if (n[24]++ > 0) check ('a string 24'); break;
    case 25: if (n[25]++ > 0) check ('a string 25'); break;
    case 26: if (n[26]++ > 0) check ('a string 26'); break;
    case 27: if (n[27]++ > 0) check ('a string 27'); break;
    case 28: if (n[28]++ > 0) check ('a string 28'); break;
    case 29: if (n[29]++ > 0) check ('a string 29'); break;
    case 30: if (n[30]++ > 0) check ('a string 30'); break;
    case 31: if (n[31]++ > 0) check ('a string 31'); break;
    case 32: if (n[32]++ > 0) check ('a string 32'); break;
    case 33: if (n[33]++ > 0) check ('a string 33'); break;
    case 34: if (n[34]++ > 0) check ('a string 34'); break;
    case 35: if (n[35]++ > 0) check ('a string 35'); break;
    case 36: if (n[36]++ > 0) check ('a string 36'); break;
    case 37: if (n[37]++ > 0) check ('a string 37'); break;
    case 38: if (n[38]++ > 0) check ('a string 38'); break;
    case 39: if (n[39]++ > 0) check ('a string 39'); break;
    case 40: if (n[40]++ > 0) check ('a string 40'); break;
    case 41: if (n[41]++ > 0) check ('a string 41'); break;
    case 42: if (n[42]++ > 0) check ('a string 42'); break;
    case 43: if (n[43]++ > 0) check ('a string 43'); break;
    case 44: if (n[44]++ > 0) check ('a string 44'); break;
    case 45: if (n[45]++ > 0) check ('a string 45'); break;
    case 46: if (n[46]++ > 0) check ('a string 46'); break;
    case 47: if (n[47]++ > 0) check ('a string 47'); break;
    case 48: if (n[48]++ > 0) check ('a string 48'); break;
    case 49: if (n[49]++ > 0) check ('a string 49'); break;
    case 50: if (n[50]++ > 0) check ('a string 50'); break;
    case 51: if (n[51]++ > 0) check ('a string 51'); break;
    case 52: if (n[52]++ > 0) check ('a string 52'); break;
    case 53: if (n[53]++ > 0) check ('a string 53'); break;
    case 54: if (n[54]++ > 0) check ('a string 54'); break;
    case 55: if (n[55]++ > 0) check ('a string 55'); break;
    case 56: if (n[56]++ > 0) check ('a string 56'); break;
    case 57: if (n[57]++ > 0) check ('a string 57'); break;
    case 58: if (n[58]++ > 0) check ('a string 58'); break;
    case 59: if (n[59]++ > 0) check ('a string 59'); break;
    case 60: if (n[60]++ > 0) check ('a string 60'); break;
    case 61: if (n[61]++ > 0) check ('a string 61'); break;
    case 62: if (n[62]++ > 0) check ('a string 62'); break;
    case 63: if (n[63]++ > 0) check ('a string 63'); break;
    case 64: if (n[64]++ > 0) check ('a string 64'); break;
    case 65: if (n[65]++ > 0) check ('a string 65'); break;
    case 66: if (n[66]++ > 0) check ('a string 66'); break;
    case 67: if (n[67]++ > 0) check ('a string 67'); break;
    case 68: if (n[68]++ > 0) check ('a string 68'); break;
    case 69: if (n[69]++ > 0) check ('a string 69'); break;
    case 70: if (n[70]++ > 0) check ('a string 70'); break;
    case 71: if (n[71]++ > 0) check ('a string 71'); break;
    case 72: if (n[72]++ > 0) check ('a string 72'); break;
    case 73: if (n[73]++ > 0) check ('a string 73'); break;
    case 74: if (n[74]++ > 0) check ('a string 74'); break;
    case 75: if (n[75]++ > 0) check ('a string 75'); break;
    case 76: if (n[76]++ > 0) check ('a string 76'); break;
    case 77: if (n[77]++ > 0) check ('a string 77'); break;
    case 78: if (n[78]++ > 0) check ('a string 78'); break;
    case 79: if (n[79]++ > 0) check ('a string 79'); break;
    case 80: if (n[80]++ > 0) check ('a string 80'); break;
    case 81: if (n[81]++ > 0) check ('a string 81'); break;
    case 82: if (n[82]++ > 0) check ('a string 82'); break;
    case 83: if (n[83]++ > 0) check ('a string 83'); break;
    case 84: if (n[84]++ > 0) check ('a string 84'); break;
    case 85: if (n[85]++ > 0) check ('a string 85'); break;
    case 86: if (n[86]++ > 0) check ('a string 86'); break;
    case 87: if (n[87]++ > 0) check ('a string 87'); break;
    case 88: if (n[88]++ > 0) check ('a string 88'); break;
    case 89: if (n[89]++ > 0) check ('a string 89'); break;
    case 90: if (n[90]++ > 0) check ('a string 90'); break;
    case 91: if (n[91]++ > 0) check ('a string 91'); break;
    case 92: if (n[92]++ > 0) check ('a string 92'); break;
    case 93: if (n[93]++ > 0) check ('a string 93'); break;
    case 94: if (n[94]++ > 0) check ('a string 94'); break;
    case 95: if (n[95]++ > 0) check ('a string 95'); break;
    case 96: if (n[96]++ > 0) check ('a string 96'); break;
    case 97: if (n[97]++ > 0) check ('a string 97'); break;
    case 98: if (n[98]++ > 0) check ('a string 98'); break;
    case 99: if (n[99]++ > 0) check ('a string 99'); break;
    case 100: if (n[100]++ > 0) check ('a string 100'); break;
    case 101: if (n[101]++ > 0) check ('a string 101'); break;
    case 102: if (n[102]++ > 0) check ('a string 102'); break;
    case 103: if (n[103]++ > 0) check ('a string 103'); break;
    case 104: if (n[104]++ > 0) check ('a string 104'); break;
    case 105: if (n[105]++ > 0) check ('a string 105'); break;
    case 106: if (n[106]++ > 0) check ('a string 106'); break;
    case 107: if (n[107]++ > 0) check ('a string 107'); break;
    case 108: if (n[108]++ > 0) check ('a string 108'); break;
    case 109: if (n[109]++ > 0) check ('a string 109'); break;
    case 110: if (n[110]++ > 0) check ('a string 110'); break;
    case 111: if (n[111]++ > 0) check ('a string 111'); break;
    case 112: if (n[112]++ > 0) check ('a string 112'); break;
    case 113: if (n[113]++ > 0) check ('a string 113'); break;
    case 114: if (n[114]++ > 0) check ('a string 114'); break;
    case 115: if (n[115]++ > 0) check ('a string 115'); break;
    case 116: if (n[116]++ > 0) check ('a string 116'); break;
    case 117: if (n[117]++ > 0) check ('a string 117'); break;
    case 118: if (n[118]++ > 0) check ('a string 118'); break;
    case 119: if (n[119]++ > 0) check ('a string 119'); break;
    case 120: if (n[120]++ > 0) check ('a string 120'); break;
    case 121: if (n[121]++ > 0) check ('a string 121'); break;
    case 122: if (n[122]++ > 0) check ('a string 122'); break;
    case 123: if (n[123]++ > 0) check ('a string 123'); break;
    case 124: if (n[124]++ > 0) check ('a string 124'); break;
    case 125: if (n[125]++ > 0) check ('a string 125'); break;
    case 126: if (n[126]++ > 0) check ('a string 126'); break;
    case 127: if (n[127]++ > 0) check ('a string 127'); break;
    case 128: if (n[128]++ > 0) check ('a string 128'); break;
    case 129: if (n[129]++ > 0) check ('a string 129'); break;
    case 130: if (n[130]++ > 0) check ('a string 130'); break;
    case 131: if (n[131]++ > 0) check ('a string 131'); break;
    case 132: if (n[132]++ > 0) check ('a string 132'); break;
    case 133: if (n[133]++ > 0) check ('a string 133'); break;
    case 134: if (n[134]++ > 0) check ('a string 134'); break;
    case 135: if (n[135]++ > 0) check ('a string 135'); break;
    case 136: if (n[136]++ > 0) check ('a string 136'); break;
    case 137: if (n[137]++ > 0) check ('a string 137'); break;
    case 138: if (n[138]++ > 0) check ('a string 138'); break;
    case 139: if (n[139]++ > 0) check ('a string 139'); break;
    case 140: if (n[140]++ > 0) check ('a string 140'); break;
    case 141: if (n[141]++ > 0) check ('a string 141'); break;
    case 142: if (n[142]++ > 0) check ('a string 142'); break;
    case 143: if (n[143]++ > 0) check ('a string 143'); break;
    case 144: if (n[144]++ > 0) check ('a string 144'); break;
    case 145: if (n[145]++ > 0) check ('a string 145'); break;
    case 146: if (n[146]++ > 0) check ('a string 146'); break;
    case 147: if (n[147]++ > 0) check ('a string 147'); break;
    case 148: if (n[148]++ > 0) check ('a string 148'); break;
    case 149: if (n[149]++ > 0) check ('a string 149'); break;
    case 150: if (n[150]++ > 0) check ('a string 150'); break;
    case 151: if (n[151]++ > 0) check ('a string 151'); break;
    case 152: if (n[152]++ > 0) check ('a string 152'); break;
    case 153: if (n[153]++ > 0) check ('a string 153'); break;
    case 154: if (n[154]++ > 0) check ('a string 154'); break;
    case 155: if (n[155]++ > 0) check ('a string 155'); break;
    case 156: if (n[156]++ > 0) check ('a string 156'); break;
    case 157: if (n[157]++ > 0) check ('a string 157'); break;
    case 158: if (n[158]++ > 0) check ('a string 158'); break;
    case 159: if (n[159]++ > 0) check ('a string 159'); break;
    case 160: if (n[160]++ > 0) check ('a string 160'); break;
    case 161: if (n[161]++ > 0) check ('a string 161'); break;
    case 162: if (n[162]++ > 0) check ('a string 162'); break;
    case 163: if (n[163]++ > 0) check ('a string 163'); break;
    case 164: if (n[164]++ > 0) check ('a string 164'); break;
    case 165: if (n[165]++ > 0) check ('a string 165'); break;
    case 166: if (n[166]++ > 0) check ('a string 166'); break;
    case 167: if (n[167]++ > 0) check ('a string 167'); break;
    case 168: if (n[168]++ > 0) check ('a string 168'); break;
    case 169: if (n[169]++ > 0) check ('a string 169'); break;
    case 170: if (n[170]++ > 0) check ('a string 170'); break;
    case 171: if (n[171]++ > 0) check ('a string 171'); break;
    case 172: if (n[172]++ > 0) check ('a string 172'); break;
    case 173: if (n[173]++ > 0) check ('a string 173'); break;
    case 174: if (n[174]++ > 0) check ('a string 174'); break;
    case 175: if (n[175]++ > 0) check ('a string 175'); break;
    case 176: if (n[176]++ > 0) check ('a string 176'); break;
    case 177: if (n[177]++ > 0) check ('a string 177'); break;
    case 178: if (n[178]++ > 0) check ('a string 178'); break;
    case 179: if (n[179]++ > 0) check ('a string 179'); break;
    case 180: if (n[180]++ > 0) check ('a string 180'); break;
    case 181: if (n[181]++ > 0) check ('a string 181'); break;
    case 182: if (n[182]++ > 0) check ('a string 182'); break;
    case 183: if (n[183]++ > 0) check ('a string 183'); break;
    case 184: if (n[184]++ > 0) check ('a string 184'); break;
    case 185: if (n[185]++ > 0) check ('a string 185'); break;
    case 186: if (n[186]++ > 0) check ('a string 186'); break;
    case 187: if (n[187]++ > 0) check ('a string 187'); break;
    case 188: if (n[188]++ > 0) check ('a string 188'); break;
    case 189: if (n[189]++ > 0) check ('a string 189'); break;
    case 190: if (n[190]++ > 0) check ('a string 190'); break;
    case 191: if (n[191]++ > 0) check ('a string 191'); break;
    case 192: if (n[192]++ > 0) check ('a string 192'); break;
    case 193: if (n[193]++ > 0) check ('a string 193'); break;
    case 194: if (n[194]++ > 0) check ('a string 194'); break;
    case 195: if (n[195]++ > 0) check ('a string 195'); break;
    case 196: if (n[196]++ > 0) check ('a string 196'); break;
    case 197: if (n[197]++ > 0) check ('a string 197'); break;
    case 198: if (n[198]++ > 0) check ('a string 198'); break;
    case 199: if (n[199]++ > 0) check ('a string 199'); break;
    case 200: if (n[200]++ > 0) check ('a string 200'); break;
    case 201: if (n[201]++ > 0) check ('a string 201'); break;
    case 202: if (n[202]++ > 0) check ('a string 202'); break;
    case 203: if (n[203]++ > 0) check ('a string 203'); break;
    case 204: if (n[204]++ > 0) check ('a string 204'); break;
    case 205: if (n[205]++ > 0) check ('a string 205'); break;
    case 206: if (n[206]++ > 0) check ('a string 206'); break;
    case 207: if (n[207]++ > 0) check ('a string 207'); break;
    case 208: if (n[208]++ > 0) check ('a string 208'); break;
    case 209: if (n[209]++ > 0) check ('a string 209'); break;
    case 210: if (n[210]++ > 0) check ('a string 210'); break;
    case 211: if (n[211]++ > 0) check ('a string 211'); break;
    case 212: if (n[212]++ > 0) check ('a string 212'); break;
    case 213: if (n[213]++ > 0) check ('a string 213'); break;
    case 214: if (n[214]++ > 0) check ('a string 214'); break;
    case 215: if (n[215]++ > 0) check ('a string 215'); break;
    case 216: if (n[216]++ > 0) check ('a string 216'); break;
    case 217: if (n[217]++ > 0) check ('a string 217'); break;
    case 218: if (n[218]++ > 0) check ('a string 218'); break;
    case 219: if (n[219]++ > 0) check ('a string 219'); break;
    case 220: if (n[220]++ > 0) check ('a string 220'); break;
    case 221: if (n[221]++ > 0) check ('a string 221'); break;
    case 222: if (n[222]++ > 0) check ('a string 222'); break;
    case 223: if (n[223]++ > 0) check ('a string 223'); break;
    case 224: if (n[224]++ > 0) check ('a string 224'); break;
    case 225: if (n[225]++ > 0) check ('a string 225'); break;
    case 226: if (n[226]++ > 0) check ('a string 226'); break;
    case 227: if (n[227]++ > 0) check ('a string 227'); break;
    case 228: if (n[228]++ > 0) check ('a string 228'); break;
    case 229: if (n[229]++ > 0) check ('a string 229'); break;
    case 230: if (n[230]++ > 0) check ('a string 230'); break;
    case 231: if (n[231]++ > 0) check ('a string 231'); break;
    case 232: if (n[232]++ > 0) check ('a string 232'); break;
    case 233: if (n[233]++ > 0) check ('a string 233'); break;
    case 234: if (n[234]++ > 0) check ('a string 234'); break;
    case 235: if (n[235]++ > 0) check ('a string 235'); break;
    case 236: if (n[236]++ > 0) check ('a string 236'); break;
    case 237: if (n[237]++ > 0) check ('a string 237'); break;
    case 238: if (n[238]++ > 0) check ('a string 238'); break;
    case 239: if (n[239]++ > 0) check ('a string 239'); break;
    case 240: if (n[240]++ > 0) check ('a string 240'); break;
    case 241: if (n[241]++ > 0) check ('a string 241'); break;
    case 242: if (n[242]++ > 0) check ('a string 242'); break;
    case 243: if (n[243]++ > 0) check ('a string 243'); break;
    case 244: if (n[244]++ > 0) check ('a string 244'); break;
    case 245: if (n[245]++ > 0) check ('a string 245'); break;
    case 246: if (n[246]++ > 0) check ('a string 246'); break;
    case 247: if (n[247]++ > 0) check ('a string 247'); break;
    case 248: if (n[248]++ > 0) check ('a string 248'); break;
    case 249: if (n[249]++ > 0) check ('a string 249'); break;
    case 250: if (n[250]++ > 0) check ('a string 250'); break;
    case 251: if (n[251]++ > 0) check ('a string 251'); break;
    case 252: if (n[252]++ > 0) check ('a string 252'); break;
    case 253: if (n[253]++ > 0) check ('a string 253'); break;
    case 254: if (n[254]++ > 0) check ('a string 254'); break;
    case 255: if (n[255]++ > 0) check ('a string 255'); break;
    case 256: if (n[256]++ > 0) check ('a string 256'); break;
    case 257: if (n[257]++ > 0) check ('a string 257'); break;
    case 258: if (n[258]++ > 0) check ('a string 258'); break;
    case 259: if (n[259]++ > 0) check ('a string 259'); break;
    case 260: if (n[260]++ > 0) check ('a string 260'); break;
    case 261: if (n[261]++ > 0) check ('a string 261'); break;
    case 262: if (n[262]++ > 0) check ('a string 262'); break;
    case 263: if (n[263]++ > 0) check ('a string 263'); break;
    case 264: if (n[264]++ > 0) check ('a string 264'); break;
    case 265: if (n[265]++ > 0) check ('a string 265'); break;
    case 266: if (n[266]++ > 0) check ('a string 266'); break;
    case 267: if (n[267]++ > 0) check ('a string 267'); break;
    case 268: if (n[268]++ > 0) check ('a string 268'); break;
    case 269: if (n[269]++ > 0) check ('a string 269'); break;
    case 270: if (n[270]++ > 0) check ('a string 270'); break;
    case 271: if (n[271]++ > 0) check ('a string 271'); break;
    case 272: if (n[272]++ > 0) check ('a string 272'); break;
    case 273: if (n[273]++ > 0) check ('a string 273'); break;
    case 274: if (n[274]++ > 0) check ('a string 274'); break;
    case 275: if (n[275]++ > 0) check ('a string 275'); break;
    case 276: if (n[276]++ > 0) check ('a string 276'); break;
    case 277: if (n[277]++ > 0) check ('a string 277'); break;
    case 278: if (n[278]++ > 0) check ('a string 278'); break;
    case 279: if (n[279]++ > 0) check ('a string 279'); break;
    case 280: if (n[280]++ > 0) check ('a string 280'); break;
    case 281: if (n[281]++ > 0) check ('a string 281'); break;
    case 282: if (n[282]++ > 0) check ('a string 282'); break;
    case 283: if (n[283]++ > 0) check ('a string 283'); break;
    case 284: if (n[284]++ > 0) check ('a string 284'); break;
    case 285: if (n[285]++ > 0) check ('a string 285'); break;
    case 286: if (n[286]++ > 0) check ('a string 286'); break;
    case 287: if (n[287]++ > 0) check ('a string 287'); break;
    case 288: if (n[288]++ > 0) check ('a string 288'); break;
    case 289: if (n[289]++ > 0) check ('a string 289'); break;
    case 290: if (n[290]++ > 0) check ('a string 290'); break;
    case 291: if (n[291]++ > 0) check ('a string 291'); break;
    case 292: if (n[292]++ > 0) check ('a string 292'); break;
    case 293: if (n[293]++ > 0) check ('a string 293'); break;
    case 294: if (n[294]++ > 0) check ('a string 294'); break;
    case 295: if (n[295]++ > 0) check ('a string 295'); break;
    case 296: if (n[296]++ > 0) check ('a string 296'); break;
    case 297: if (n[297]++ > 0) check ('a string 297'); break;
    case 298: if (n[298]++ > 0) check ('a string 298'); break;
    case 299: if (n[299]++ > 0) check ('a string 299'); break;
    case 300: if (n[300]++ > 0) check ('a string 300'); break;
    case 301: if (n[301]++ > 0) check ('a string 301'); break;
    case 302: if (n[302]++ > 0) check ('a string 302'); break;
    case 303: if (n[303]++ > 0) check ('a string 303'); break;
    case 304: if (n[304]++ > 0) check ('a string 304'); break;
    case 305: if (n[305]++ > 0) check ('a string 305'); break;
    case 306: if (n[306]++ > 0) check ('a string 306'); break;
    case 307: if (n[307]++ > 0) check ('a string 307'); break;
    case 308: if (n[308]++ > 0) check ('a string 308'); break;
    case 309: if (n[309]++ > 0) check ('a string 309'); break;
    case 310: if (n[310]++ > 0) check ('a string 310'); break;
    case 311: if (n[311]++ > 0) check ('a string 311'); break;
    case 312: if (n[312]++ > 0) check ('a string 312'); break;
    case 313: if (n[313]++ > 0) check ('a string 313'); break;
    case 314: if (n[314]++ > 0) check ('a string 314'); break;
    case 315: if (n[315]++ > 0) check ('a string 315'); break;
    case 316: if (n[316]++ > 0) check ('a string 316'); break;
    case 317: if (n[317]++ > 0) check ('a string 317'); break;
    case 318: if (n[318]++ > 0) check ('a string 318'); break;
    case 319: if (n[319]++ > 0) check ('a string 319'); break;
    case 320: if (n[320]++ > 0) check ('a string 320'); break;
    case 321: if (n[321]++ > 0) check ('a string 321'); break;
    case 322: if (n[322]++ > 0) check ('a string 322'); break;
    case 323: if (n[323]++ > 0) check ('a string 323'); break;
    case 324: if (n[324]++ > 0) check ('a string 324'); break;
    case 325: if (n[325]++ > 0) check ('a string 325'); break;
    case 326: if (n[326]++ > 0) check ('a string 326'); break;
    case 327: if (n[327]++ > 0) check ('a string 327'); break;
    case 328: if (n[328]++ > 0) check ('a string 328'); break;
    case 329: if (n[329]++ > 0) check ('a string 329'); break;
    case 330: if (n[330]++ > 0) check ('a string 330'); break;
    case 331: if (n[331]++ > 0) check ('a string 331'); break;
    case 332: if (n[332]++ > 0) check ('a string 332'); break;
    case 333: if (n[333]++ > 0) check ('a string 333'); break;
    case 334: if (n[334]++ > 0) check ('a string 334'); break;
    case 335: if (n[335]++ > 0) check ('a string 335'); break;
    case 336: if (n[336]++ > 0) check ('a string 336'); break;
    case 337: if (n[337]++ > 0) check ('a string 337'); break;
    case 338: if (n[338]++ > 0) check ('a string 338'); break;
    case 339: if (n[339]++ > 0) check ('a string 339'); break;
    case 340: if (n[340]++ > 0) check ('a string 340'); break;
    case 341: if (n[341]++ > 0) check ('a string 341'); break;
    case 342: if (n[342]++ > 0) check ('a string 342'); break;
    case 343: if (n[343]++ > 0) check ('a string 343'); break;
    case 344: if (n[344]++ > 0) check ('a string 344'); break;
    case 345: if (n[345]++ > 0) check ('a string 345'); break;
    case 346: if (n[346]++ > 0) check ('a string 346'); break;
    case 347: if (n[347]++ > 0) check ('a string 347'); break;
    case 348: if (n[348]++ > 0) check ('a string 348'); break;
    case 349: if (n[349]++ > 0) check ('a string 349'); break;
    case 350: if (n[350]++ > 0) check ('a string 350'); break;
    case 351: if (n[351]++ > 0) check ('a string 351'); break;
    case 352: if (n[352]++ > 0) check ('a string 352'); break;
    case 353: if (n[353]++ > 0) check ('a string 353'); break;
    case 354: if (n[354]++ > 0) check ('a string 354'); break;
    case 355: if (n[355]++ > 0) check ('a string 355'); break;
    case 356: if (n[356]++ > 0) check ('a string 356'); break;
    case 357: if (n[357]++ > 0) check ('a string 357'); break;
    case 358: if (n[358]++ > 0) check ('a string 358'); break;
    case 359: if (n[359]++ > 0) check ('a string 359'); break;
    case 360: if (n[360]++ > 0) check ('a string 360'); break;
    case 361: if (n[361]++ > 0) check ('a string 361'); break;
    case 362: if (n[362]++ > 0) check ('a string 362'); break;
    case 363: if (n[363]++ > 0) check ('a string 363'); break;
    case 364: if (n[364]++ > 0) check ('a string 364'); break;
    case 365: if (n[365]++ > 0) check ('a string 365'); break;
    case 366: if (n[366]++ > 0) check ('a string 366'); break;
    case 367: if (n[367]++ > 0) check ('a string 367'); break;
    case 368: if (n[368]++ > 0) check ('a string 368'); break;
    case 369: if (n[369]++ > 0) check ('a string 369'); break;
    case 370: if (n[370]++ > 0) check ('a string 370'); break;
    case 371: if (n[371]++ > 0) check ('a string 371'); break;
    case 372: if (n[372]++ > 0) check ('a string 372'); break;
    case 373: if (n[373]++ > 0) check ('a string 373'); break;
    case 374: if (n[374]++ > 0) check ('a string 374'); break;
    case 375: if (n[375]++ > 0) check ('a string 375'); break;
    case 376: if (n[376]++ > 0) check ('a string 376'); break;
    case 377: if (n[377]++ > 0) check ('a string 377'); break;
    case 378: if (n[378]++ > 0) check ('a string 378'); break;
    case 379: if (n[379]++ > 0) check ('a string 379'); break;
    case 380: if (n[380]++ > 0) check ('a string 380'); break;
    case 381: if (n[381]++ > 0) check ('a string 381'); break;
    case 382: if (n[382]++ > 0) check ('a string 382'); break;
    case 383: if (n[383]++ > 0) check ('a string 383'); break;
    case 384: if (n[384]++ > 0) check ('a string 384'); break;
    case 385: if (n[385]++ > 0) check ('a string 385'); break;
    case 386: if (n[386]++ > 0) check ('a string 386'); break;
    case 387: if (n[387]++ > 0) check ('a string 387'); break;
    case 388: if (n[388]++ > 0) check ('a string 388'); break;
    case 389: if (n[389]++ > 0) check ('a string 389'); break;
    case 390: if (n[390]++ > 0) check ('a string 390'); break;
    case 391: if (n[391]++ > 0) check ('a string 391'); break;
    case 392: if (n[392]++ > 0) check ('a string 392'); break;
    case 393: if (n[393]++ > 0) check ('a string 393'); break;
    case 394: if (n[394]++ > 0) check ('a string 394'); break;
    case 395: if (n[395]++ > 0) check ('a string 395'); break;
    case 396: if (n[396]++ > 0) check ('a string 396'); break;
    case 397: if (n[397]++ > 0) check ('a string 397'); break;
    case 398: if (n[398]++ > 0) check ('a string 398'); break;
    case 399: if (n[399]++ > 0) check ('a string 399'); break;
    case 400: if (n[400]++ > 0) check ('a string 400'); break;
    case 401: if (n[401]++ > 0) check ('a string 401'); break;
    case 402: if (n[402]++ > 0) check ('a string 402'); break;
    case 403: if (n[403]++ > 0) check ('a string 403'); break;
    case 404: if (n[404]++ > 0) check ('a string 404'); break;
    case 405: if (n[405]++ > 0) check ('a string 405'); break;
    case 406: if (n[406]++ > 0) check ('a string 406'); break;
    case 407: if (n[407]++ > 0) check ('a string 407'); break;
    case 408: if (n[408]++ > 0) check ('a string 408'); break;
    case 409: if (n[409]++ > 0) check ('a string 409'); break;
    case 410: if (n[410]++ > 0) check ('a string 410'); break;
    case 411: if (n[411]++ > 0) check ('a string 411'); break;
    case 412: if (n[412]++ > 0) check ('a string 412'); break;
    case 413: if (n[413]++ > 0) check ('a string 413'); break;
    case 414: if (n[414]++ > 0) check ('a string 414'); break;
    case 415: if (n[415]++ > 0) check ('a string 415'); break;
    case 416: if (n[416]++ > 0) check ('a string 416'); break;
    case 417: if (n[417]++ > 0) check ('a string 417'); break;
    case 418: if (n[418]++ > 0) check ('a string 418'); break;
    case 419: if (n[419]++ > 0) check ('a string 419'); break;
    case 420: if (n[420]++ > 0) check ('a string 420'); break;
    case 421: if (n[421]++ > 0) check ('a string 421'); break;
    case 422: if (n[422]++ > 0) check ('a string 422'); break;
    case 423: if (n[423]++ > 0) check ('a string 423'); break;
    case 424: if (n[424]++ > 0) check ('a string 424'); break;
    case 425: if (n[425]++ > 0) check ('a string 425'); break;
    case 426: if (n[426]++ > 0) check ('a string 426'); break;
    case 427: if (n[427]++ > 0) check ('a string 427'); break;
    case 428: if (n[428]++ > 0) check ('a string 428'); break;
    case 429: if (n[429]++ > 0) check ('a string 429'); break;
    case 430: if (n[430]++ > 0) check ('a string 430'); break;
    case 431: if (n[431]++ > 0) check ('a string 431'); break;
    case 432: if (n[432]++ > 0) check ('a string 432'); break;
    case 433: if (n[433]++ > 0) check ('a string 433'); break;
    case 434: if (n[434]++ > 0) check ('a string 434'); break;
    case 435: if (n[435]++ > 0) check ('a string 435'); break;
    case 436: if (n[436]++ > 0) check ('a string 436'); break;
    case 437: if (n[437]++ > 0) check ('a string 437'); break;
    case 438: if (n[438]++ > 0) check ('a string 438'); break;
    case 439: if (n[439]++ > 0) check ('a string 439'); break;
    case 440: if (n[440]++ > 0) check ('a string 440'); break;
    case 441: if (n[441]++ > 0) check ('a string 441'); break;
    case 442: if (n[442]++ > 0) check ('a string 442'); break;
    case 443: if (n[443]++ > 0) check ('a string 443'); break;
    case 444: if (n[444]++ > 0) check ('a string 444'); break;
    case 445: if (n[445]++ > 0) check ('a string 445'); break;
    case 446: if (n[446]++ > 0) check ('a string 446'); break;
    case 447: if (n[447]++ > 0) check ('a string 447'); break;
    case 448: if (n[448]++ > 0) check ('a string 448'); break;
    case 449: if (n[449]++ > 0) check ('a string 449'); break;
    case 450: if (n[450]++ > 0) check ('a string 450'); break;
    case 451: if (n[451]++ > 0) check ('a string 451'); break;
    case 452: if (n[452]++ > 0) check ('a string 452'); break;
    case 453: if (n[453]++ > 0) check ('a string 453'); break;
    case 454: if (n[454]++ > 0) check ('a string 454'); break;
    case 455: if (n[455]++ > 0) check ('a string 455'); break;
    case 456: if (n[456]++ > 0) check ('a string 456'); break;
    case 457: if (n[457]++ > 0) check ('a string 457'); break;
    case 458: if (n[458]++ > 0) check ('a string 458'); break;
    case 459: if (n[459]++ > 0) check ('a string 459'); break;
    case 460: if (n[460]++ > 0) check ('a string 460'); break;
    case 461: if (n[461]++ > 0) check ('a string 461'); break;
    case 462: if (n[462]++ > 0) check ('a string 462'); break;
    case 463: if (n[463]++ > 0) check ('a string 463'); break;
    case 464: if (n[464]++ > 0) check ('a string 464'); break;
    case 465: if (n[465]++ > 0) check ('a string 465'); break;
    case 466: if (n[466]++ > 0) check ('a string 466'); break;
    case 467: if (n[467]++ > 0) check ('a string 467'); break;
    case 468: if (n[468]++ > 0) check ('a string 468'); break;
    case 469: if (n[469]++ > 0) check ('a string 469'); break;
    case 470: if (n[470]++ > 0) check ('a string 470'); break;
    case 471: if (n[471]++ > 0) check ('a string 471'); break;
    case 472: if (n[472]++ > 0) check ('a string 472'); break;
    case 473: if (n[473]++ > 0) check ('a string 473'); break;
    case 474: if (n[474]++ > 0) check ('a string 474'); break;
    case 475: if (n[475]++ > 0) check ('a string 475'); break;
    case 476: if (n[476]++ > 0) check ('a string 476'); break;
    case 477: if (n[477]++ > 0) check ('a string 477'); break;
    case 478: if (n[478]++ > 0) check ('a string 478'); break;
    case 479: if (n[479]++ > 0) check ('a string 479'); break;
    case 480: if (n[480]++ > 0) check ('a string 480'); break;
    case 481: if (n[481]++ > 0) check ('a string 481'); break;
    case 482: if (n[482]++ > 0) check ('a string 482'); break;
    case 483: if (n[483]++ > 0) check ('a string 483'); break;
    case 484: if (n[484]++ > 0) check ('a string 484'); break;
    case 485: if (n[485]++ > 0) check ('a string 485'); break;
    case 486: if (n[486]++ > 0) check ('a string 486'); break;
    case 487: if (n[487]++ > 0) check ('a string 487'); break;
    case 488: if (n[488]++ > 0) check ('a string 488'); break;
    case 489: if (n[489]++ > 0) check ('a string 489'); break;
    case 490: if (n[490]++ > 0) check ('a string 490'); break;
    case 491: if (n[491]++ > 0) check ('a string 491'); break;
    case 492: if (n[492]++ > 0) check ('a string 492'); break;
    case 493: if (n[493]++ > 0) check ('a string 493'); break;
    case 494: if (n[494]++ > 0) check ('a string 494'); break;
    case 495: if (n[495]++ > 0) check ('a string 495'); break;
    case 496: if (n[496]++ > 0) check ('a string 496'); break;
    case 497: if (n[497]++ > 0) check ('a string 497'); break;
    case 498: if (n[498]++ > 0) check ('a string 498'); break;
    case 499: if (n[499]++ > 0) check ('a string 499'); break;
    case 500: if (n[500]++ > 0) check ('a string 500'); break;
    case 501: if (n[501]++ > 0) check ('a string 501'); break;
    case 502: if (n[502]++ > 0) check ('a string 502'); break;
    case 503: if (n[503]++ > 0) check ('a string 503'); break;
    case 504: if (n[504]++ > 0) check ('a string 504'); break;
    case 505: if (n[505]++ > 0) check ('a string 505'); break;
    case 506: if (n[506]++ > 0) check ('a string 506'); break;
    case 507: if (n[507]++ > 0) check ('a string 507'); break;
    case 508: if (n[508]++ > 0) check ('a string 508'); break;
    case 509: if (n[509]++ > 0) check ('a string 509'); break;
    case 510: if (n[510]++ > 0) check ('a string 510'); break;
    case 511: if (n[511]++ > 0) check ('a string 511'); break;
    case 512: if (n[512]++ > 0) check ('a string 512'); break;
    case 513: if (n[513]++ > 0) check ('a string 513'); break;
    case 514: if (n[514]++ > 0) check ('a string 514'); break;
    case 515: if (n[515]++ > 0) check ('a string 515'); break;
    case 516: if (n[516]++ > 0) check ('a string 516'); break;
    case 517: if (n[517]++ > 0) check ('a string 517'); break;
    case 518: if (n[518]++ > 0) check ('a string 518'); break;
    case 519: if (n[519]++ > 0) check ('a string 519'); break;
    case 520: if (n[520]++ > 0) check ('a string 520'); break;
    case 521: if (n[521]++ > 0) check ('a string 521'); break;
    case 522: if (n[522]++ > 0) check ('a string 522'); break;
    case 523: if (n[523]++ > 0) check ('a string 523'); break;
    case 524: if (n[524]++ > 0) check ('a string 524'); break;
    case 525: if (n[525]++ > 0) check ('a string 525'); break;
    case 526: if (n[526]++ > 0) check ('a string 526'); break;
    case 527: if (n[527]++ > 0) check ('a string 527'); break;
    case 528: if (n[528]++ > 0) check ('a string 528'); break;
    case 529: if (n[529]++ > 0) check ('a string 529'); break;
    case 530: if (n[530]++ > 0) check ('a string 530'); break;
    case 531: if (n[531]++ > 0) check ('a string 531'); break;
    case 532: if (n[532]++ > 0) check ('a string 532'); break;
    case 533: if (n[533]++ > 0) check ('a string 533'); break;
    case 534: if (n[534]++ > 0) check ('a string 534'); break;
    case 535: if (n[535]++ > 0) check ('a string 535'); break;
    case 536: if (n[536]++ > 0) check ('a string 536'); break;
    case 537: if (n[537]++ > 0) check ('a string 537'); break;
    case 538: if (n[538]++ > 0) check ('a string 538'); break;
    case 539: if (n[539]++ > 0) check ('a string 539'); break;
    case 540: if (n[540]++ > 0) check ('a string 540'); break;
    case 541: if (n[541]++ > 0) check ('a string 541'); break;
    case 542: if (n[542]++ > 0) check ('a string 542'); break;
    case 543: if (n[543]++ > 0) check ('a string 543'); break;
    case 544: if (n[544]++ > 0) check ('a string 544'); break;
    case 545: if (n[545]++ > 0) check ('a string 545'); break;
    case 546: if (n[546]++ > 0) check ('a string 546'); break;
    case 547: if (n[547]++ > 0) check ('a string 547'); break;
    case 548: if (n[548]++ > 0) check ('a string 548'); break;
    case 549: if (n[549]++ > 0) check ('a string 549'); break;
    case 550: if (n[550]++ > 0) check ('a string 550'); break;
    case 551: if (n[551]++ > 0) check ('a string 551'); break;
    case 552: if (n[552]++ > 0) check ('a string 552'); break;
    case 553: if (n[553]++ > 0) check ('a string 553'); break;
    case 554: if (n[554]++ > 0) check ('a string 554'); break;
    case 555: if (n[555]++ > 0) check ('a string 555'); break;
    case 556: if (n[556]++ > 0) check ('a string 556'); break;
    case 557: if (n[557]++ > 0) check ('a string 557'); break;
    case 558: if (n[558]++ > 0) check ('a string 558'); break;
    case 559: if (n[559]++ > 0) check ('a string 559'); break;
    case 560: if (n[560]++ > 0) check ('a string 560'); break;
    case 561: if (n[561]++ > 0) check ('a string 561'); break;
    case 562: if (n[562]++ > 0) check ('a string 562'); break;
    case 563: if (n[563]++ > 0) check ('a string 563'); break;
    case 564: if (n[564]++ > 0) check ('a string 564'); break;
    case 565: if (n[565]++ > 0) check ('a string 565'); break;
    case 566: if (n[566]++ > 0) check ('a string 566'); break;
    case 567: if (n[567]++ > 0) check ('a string 567'); break;
    case 568: if (n[568]++ > 0) check ('a string 568'); break;
    case 569: if (n[569]++ > 0) check ('a string 569'); break;
    case 570: if (n[570]++ > 0) check ('a string 570'); break;
    case 571: if (n[571]++ > 0) check ('a string 571'); break;
    case 572: if (n[572]++ > 0) check ('a string 572'); break;
    case 573: if (n[573]++ > 0) check ('a string 573'); break;
    case 574: if (n[574]++ > 0) check ('a string 574'); break;
    case 575: if (n[575]++ > 0) check ('a string 575'); break;
    case 576: if (n[576]++ > 0) check ('a string 576'); break;
    case 577: if (n[577]++ > 0) check ('a string 577'); break;
    case 578: if (n[578]++ > 0) check ('a string 578'); break;
    case 579: if (n[579]++ > 0) check ('a string 579'); break;
    case 580: if (n[580]++ > 0) check ('a string 580'); break;
    case 581: if (n[581]++ > 0) check ('a string 581'); break;
    case 582: if (n[582]++ > 0) check ('a string 582'); break;
    case 583: if (n[583]++ > 0) check ('a string 583'); break;
    case 584: if (n[584]++ > 0) check ('a string 584'); break;
    case 585: if (n[585]++ > 0) check ('a string 585'); break;
    case 586: if (n[586]++ > 0) check ('a string 586'); break;
    case 587: if (n[587]++ > 0) check ('a string 587'); break;
    case 588: if (n[588]++ > 0) check ('a string 588'); break;
    case 589: if (n[589]++ > 0) check ('a string 589'); break;
    case 590: if (n[590]++ > 0) check ('a string 590'); break;
    case 591: if (n[591]++ > 0) check ('a string 591'); break;
    case 592: if (n[592]++ > 0) check ('a string 592'); break;
    case 593: if (n[593]++ > 0) check ('a string 593'); break;
    case 594: if (n[594]++ > 0) check ('a string 594'); break;
    case 595: if (n[595]++ > 0) check ('a string 595'); break;
    case 596: if (n[596]++ > 0) check ('a string 596'); break;
    case 597: if (n[597]++ > 0) check ('a string 597'); break;
    case 598: if (n[598]++ > 0) check ('a string 598'); break;
    case 599: if (n[599]++ > 0) check ('a string 599'); break;
    case 600: if (n[600]++ > 0) check ('a string 600'); break;
    case 601: if (n[601]++ > 0) check ('a string 601'); break;
    case 602: if (n[602]++ > 0) check ('a string 602'); break;
    case 603: if (n[603]++ > 0) check ('a string 603'); break;
    case 604: if (n[604]++ > 0) check ('a string 604'); break;
    case 605: if (n[605]++ > 0) check ('a string 605'); break;
    case 606: if (n[606]++ > 0) check ('a string 606'); break;
    case 607: if (n[607]++ > 0) check ('a string 607'); break;
    case 608: if (n[608]++ > 0) check ('a string 608'); break;
    case 609: if (n[609]++ > 0) check ('a string 609'); break;
    case 610: if (n[610]++ > 0) check ('a string 610'); break;
    case 611: if (n[611]++ > 0) check ('a string 611'); break;
    case 612: if (n[612]++ > 0) check ('a string 612'); break;
    case 613: if (n[613]++ > 0) check ('a string 613'); break;
    case 614: if (n[614]++ > 0) check ('a string 614'); break;
    case 615: if (n[615]++ > 0) check ('a string 615'); break;
    case 616: if (n[616]++ > 0) check ('a string 616'); break;
    case 617: if (n[617]++ > 0) check ('a string 617'); break;
    case 618: if (n[618]++ > 0) check ('a string 618'); break;
    case 619: if (n[619]++ > 0) check ('a string 619'); break;
    case 620: if (n[620]++ > 0) check ('a string 620'); break;
    case 621: if (n[621]++ > 0) check ('a string 621'); break;
    case 622: if (n[622]++ > 0) check ('a string 622'); break;
    case 623: if (n[623]++ > 0) check ('a string 623'); break;
    case 624: if (n[624]++ > 0) check ('a string 624'); break;
    case 625: if (n[625]++ > 0) check ('a string 625'); break;
    case 626: if (n[626]++ > 0) check ('a string 626'); break;
    case 627: if (n[627]++ > 0) check ('a string 627'); break;
    case 628: if (n[628]++ > 0) check ('a string 628'); break;
    case 629: if (n[629]++ > 0) check ('a string 629'); break;
    case 630: if (n[630]++ > 0) check ('a string 630'); break;
    case 631: if (n[631]++ > 0) check ('a string 631'); break;
    case 632: if (n[632]++ > 0) check ('a string 632'); break;
    case 633: if (n[633]++ > 0) check ('a string 633'); break;
    case 634: if (n[634]++ > 0) check ('a string 634'); break;
    case 635: if (n[635]++ > 0) check ('a string 635'); break;
    case 636: if (n[636]++ > 0) check ('a string 636'); break;
    case 637: if (n[637]++ > 0) check ('a string 637'); break;
    case 638: if (n[638]++ > 0) check ('a string 638'); break;
    case 639: if (n[639]++ > 0) check ('a string 639'); break;
    case 640: if (n[640]++ > 0) check ('a string 640'); break;
    case 641: if (n[641]++ > 0) check ('a string 641'); break;
    case 642: if (n[642]++ > 0) check ('a string 642'); break;
    case 643: if (n[643]++ > 0) check ('a string 643'); break;
    case 644: if (n[644]++ > 0) check ('a string 644'); break;
    case 645: if (n[645]++ > 0) check ('a string 645'); break;
    case 646: if (n[646]++ > 0) check ('a string 646'); break;
    case 647: if (n[647]++ > 0) check ('a string 647'); break;
    case 648: if (n[648]++ > 0) check ('a string 648'); break;
    case 649: if (n[649]++ > 0) check ('a string 649'); break;
    case 650: if (n[650]++ > 0) check ('a string 650'); break;
    case 651: if (n[651]++ > 0) check ('a string 651'); break;
    case 652: if (n[652]++ > 0) check ('a string 652'); break;
    case 653: if (n[653]++ > 0) check ('a string 653'); break;
    case 654: if (n[654]++ > 0) check ('a string 654'); break;
    case 655: if (n[655]++ > 0) check ('a string 655'); break;
    case 656: if (n[656]++ > 0) check ('a string 656'); break;
    case 657: if (n[657]++ > 0) check ('a string 657'); break;
    case 658: if (n[658]++ > 0) check ('a string 658'); break;
    case 659: if (n[659]++ > 0) check ('a string 659'); break;
    case 660: if (n[660]++ > 0) check ('a string 660'); break;
    case 661: if (n[661]++ > 0) check ('a string 661'); break;
    case 662: if (n[662]++ > 0) check ('a string 662'); break;
    case 663: if (n[663]++ > 0) check ('a string 663'); break;
    case 664: if (n[664]++ > 0) check ('a string 664'); break;
    case 665: if (n[665]++ > 0) check ('a string 665'); break;
    case 666: if (n[666]++ > 0) check ('a string 666'); break;
    case 667: if (n[667]++ > 0) check ('a string 667'); break;
    case 668: if (n[668]++ > 0) check ('a string 668'); break;
    case 669: if (n[669]++ > 0) check ('a string 669'); break;
    case 670: if (n[670]++ > 0) check ('a string 670'); break;
    case 671: if (n[671]++ > 0) check ('a string 671'); break;
    case 672: if (n[672]++ > 0) check ('a string 672'); break;
    case 673: if (n[673]++ > 0) check ('a string 673'); break;
    case 674: if (n[674]++ > 0) check ('a string 674'); break;
    case 675: if (n[675]++ > 0) check ('a string 675'); break;
    case 676: if (n[676]++ > 0) check ('a string 676'); break;
    case 677: if (n[677]++ > 0) check ('a string 677'); break;
    case 678: if (n[678]++ > 0) check ('a string 678'); break;
    case 679: if (n[679]++ > 0) check ('a string 679'); break;
    case 680: if (n[680]++ > 0) check ('a string 680'); break;
    case 681: if (n[681]++ > 0) check ('a string 681'); break;
    case 682: if (n[682]++ > 0) check ('a string 682'); break;
    case 683: if (n[683]++ > 0) check ('a string 683'); break;
    case 684: if (n[684]++ > 0) check ('a string 684'); break;
    case 685: if (n[685]++ > 0) check ('a string 685'); break;
    case 686: if (n[686]++ > 0) check ('a string 686'); break;
    case 687: if (n[687]++ > 0) check ('a string 687'); break;
    case 688: if (n[688]++ > 0) check ('a string 688'); break;
    case 689: if (n[689]++ > 0) check ('a string 689'); break;
    case 690: if (n[690]++ > 0) check ('a string 690'); break;
    case 691: if (n[691]++ > 0) check ('a string 691'); break;
    case 692: if (n[692]++ > 0) check ('a string 692'); break;
    case 693: if (n[693]++ > 0) check ('a string 693'); break;
    case 694: if (n[694]++ > 0) check ('a string 694'); break;
    case 695: if (n[695]++ > 0) check ('a string 695'); break;
    case 696: if (n[696]++ > 0) check ('a string 696'); break;
    case 697: if (n[697]++ > 0) check ('a string 697'); break;
    case 698: if (n[698]++ > 0) check ('a string 698'); break;
    case 699: if (n[699]++ > 0) check ('a string 699'); break;
    case 700: if (n[700]++ > 0) check ('a string 700'); break;
    case 701: if (n[701]++ > 0) check ('a string 701'); break;
    case 702: if (n[702]++ > 0) check ('a string 702'); break;
    case 703: if (n[703]++ > 0) check ('a string 703'); break;
    case 704: if (n[704]++ > 0) check ('a string 704'); break;
    case 705: if (n[705]++ > 0) check ('a string 705'); break;
    case 706: if (n[706]++ > 0) check ('a string 706'); break;
    case 707: if (n[707]++ > 0) check ('a string 707'); break;
    case 708: if (n[708]++ > 0) check ('a string 708'); break;
    case 709: if (n[709]++ > 0) check ('a string 709'); break;
    case 710: if (n[710]++ > 0) check ('a string 710'); break;
    case 711: if (n[711]++ > 0) check ('a string 711'); break;
    case 712: if (n[712]++ > 0) check ('a string 712'); break;
    case 713: if (n[713]++ > 0) check ('a string 713'); break;
    case 714: if (n[714]++ > 0) check ('a string 714'); break;
    case 715: if (n[715]++ > 0) check ('a string 715'); break;
    case 716: if (n[716]++ > 0) check ('a string 716'); break;
    case 717: if (n[717]++ > 0) check ('a string 717'); break;
    case 718: if (n[718]++ > 0) check ('a string 718'); break;
    case 719: if (n[719]++ > 0) check ('a string 719'); break;
    case 720: if (n[720]++ > 0) check ('a string 720'); break;
    case 721: if (n[721]++ > 0) check ('a string 721'); break;
    case 722: if (n[722]++ > 0) check ('a string 722'); break;
    case 723: if (n[723]++ > 0) check ('a string 723'); break;
    case 724: if (n[724]++ > 0) check ('a string 724'); break;
    case 725: if (n[725]++ > 0) check ('a string 725'); break;
    case 726: if (n[726]++ > 0) check ('a string 726'); break;
    case 727: if (n[727]++ > 0) check ('a string 727'); break;
    case 728: if (n[728]++ > 0) check ('a string 728'); break;
    case 729: if (n[729]++ > 0) check ('a string 729'); break;
    case 730: if (n[730]++ > 0) check ('a string 730'); break;
    case 731: if (n[731]++ > 0) check ('a string 731'); break;
    case 732: if (n[732]++ > 0) check ('a string 732'); break;
    case 733: if (n[733]++ > 0) check ('a string 733'); break;
    case 734: if (n[734]++ > 0) check ('a string 734'); break;
    case 735: if (n[735]++ > 0) check ('a string 735'); break;
    case 736: if (n[736]++ > 0) check ('a string 736'); break;
    case 737: if (n[737]++ > 0) check ('a string 737'); break;
    case 738: if (n[738]++ > 0) check ('a string 738'); break;
    case 739: if (n[739]++ > 0) check ('a string 739'); break;
    case 740: if (n[740]++ > 0) check ('a string 740'); break;
    case 741: if (n[741]++ > 0) check ('a string 741'); break;
    case 742: if (n[742]++ > 0) check ('a string 742'); break;
    case 743: if (n[743]++ > 0) check ('a string 743'); break;
    case 744: if (n[744]++ > 0) check ('a string 744'); break;
    case 745: if (n[745]++ > 0) check ('a string 745'); break;
    case 746: if (n[746]++ > 0) check ('a string 746'); break;
    case 747: if (n[747]++ > 0) check ('a string 747'); break;
    case 748: if (n[748]++ > 0) check ('a string 748'); break;
    case 749: if (n[749]++ > 0) check ('a string 749'); break;
    case 750: if (n[750]++ > 0) check ('a string 750'); break;
    case 751: if (n[751]++ > 0) check ('a string 751'); break;
    case 752: if (n[752]++ > 0) check ('a string 752'); break;
    case 753: if (n[753]++ > 0) check ('a string 753'); break;
    case 754: if (n[754]++ > 0) check ('a string 754'); break;
    case 755: if (n[755]++ > 0) check ('a string 755'); break;
    case 756: if (n[756]++ > 0) check ('a string 756'); break;
    case 757: if (n[757]++ > 0) check ('a string 757'); break;
    case 758: if (n[758]++ > 0) check ('a string 758'); break;
    case 759: if (n[759]++ > 0) check ('a string 759'); break;
    case 760: if (n[760]++ > 0) check ('a string 760'); break;
    case 761: if (n[761]++ > 0) check ('a string 761'); break;
    case 762: if (n[762]++ > 0) check ('a string 762'); break;
    case 763: if (n[763]++ > 0) check ('a string 763'); break;
    case 764: if (n[764]++ > 0) check ('a string 764'); break;
    case 765: if (n[765]++ > 0) check ('a string 765'); break;
    case 766: if (n[766]++ > 0) check ('a string 766'); break;
    case 767: if (n[767]++ > 0) check ('a string 767'); break;
    case 768: if (n[768]++ > 0) check ('a string 768'); break;
    case 769: if (n[769]++ > 0) check ('a string 769'); break;
    case 770: if (n[770]++ > 0) check ('a string 770'); break;
    case 771: if (n[771]++ > 0) check ('a string 771'); break;
    case 772: if (n[772]++ > 0) check ('a string 772'); break;
    case 773: if (n[773]++ > 0) check ('a string 773'); break;
    case 774: if (n[774]++ > 0) check ('a string 774'); break;
    case 775: if (n[775]++ > 0) check ('a string 775'); break;
    case 776: if (n[776]++ > 0) check ('a string 776'); break;
    case 777: if (n[777]++ > 0) check ('a string 777'); break;
    case 778: if (n[778]++ > 0) check ('a string 778'); break;
    case 779: if (n[779]++ > 0) check ('a string 779'); break;
    case 780: if (n[780]++ > 0) check ('a string 780'); break;
    case 781: if (n[781]++ > 0) check ('a string 781'); break;
    case 782: if (n[782]++ > 0) check ('a string 782'); break;
    case 783: if (n[783]++ > 0) check ('a string 783'); break;
    case 784: if (n[784]++ > 0) check ('a string 784'); break;
    case 785: if (n[785]++ > 0) check ('a string 785'); break;
    case 786: if (n[786]++ > 0) check ('a string 786'); break;
    case 787: if (n[787]++ > 0) check ('a string 787'); break;
    case 788: if (n[788]++ > 0) check ('a string 788'); break;
    case 789: if (n[789]++ > 0) check ('a string 789'); break;
    case 790: if (n[790]++ > 0) check ('a string 790'); break;
    case 791: if (n[791]++ > 0) check ('a string 791'); break;
    case 792: if (n[792]++ > 0) check ('a string 792'); break;
    case 793: if (n[793]++ > 0) check ('a string 793'); break;
    case 794: if (n[794]++ > 0) check ('a string 794'); break;
    case 795: if (n[795]++ > 0) check ('a string 795'); break;
    case 796: if (n[796]++ > 0) check ('a string 796'); break;
    case 797: if (n[797]++ > 0) check ('a string 797'); break;
    case 798: if (n[798]++ > 0) check ('a string 798'); break;
    case 799: if (n[799]++ > 0) check ('a string 799'); break;
    case 800: if (n[800]++ > 0) check ('a string 800'); break;
    case 801: if (n[801]++ > 0) check ('a string 801'); break;
    case 802: if (n[802]++ > 0) check ('a string 802'); break;
    case 803: if (n[803]++ > 0) check ('a string 803'); break;
    case 804: if (n[804]++ > 0) check ('a string 804'); break;
    case 805: if (n[805]++ > 0) check ('a string 805'); break;
    case 806: if (n[806]++ > 0) check ('a string 806'); break;
    case 807: if (n[807]++ > 0) check ('a string 807'); break;
    case 808: if (n[808]++ > 0) check ('a string 808'); break;
    case 809: if (n[809]++ > 0) check ('a string 809'); break;
    case 810: if (n[810]++ > 0) check ('a string 810'); break;
    case 811: if (n[811]++ > 0) check ('a string 811'); break;
    case 812: if (n[812]++ > 0) check ('a string 812'); break;
    case 813: if (n[813]++ > 0) check ('a string 813'); break;
    case 814: if (n[814]++ > 0) check ('a string 814'); break;
    case 815: if (n[815]++ > 0) check ('a string 815'); break;
    case 816: if (n[816]++ > 0) check ('a string 816'); break;
    case 817: if (n[817]++ > 0) check ('a string 817'); break;
    case 818: if (n[818]++ > 0) check ('a string 818'); break;
    case 819: if (n[819]++ > 0) check ('a string 819'); break;
    case 820: if (n[820]++ > 0) check ('a string 820'); break;
    case 821: if (n[821]++ > 0) check ('a string 821'); break;
    case 822: if (n[822]++ > 0) check ('a string 822'); break;
    case 823: if (n[823]++ > 0) check ('a string 823'); break;
    case 824: if (n[824]++ > 0) check ('a string 824'); break;
    case 825: if (n[825]++ > 0) check ('a string 825'); break;
    case 826: if (n[826]++ > 0) check ('a string 826'); break;
    case 827: if (n[827]++ > 0) check ('a string 827'); break;
    case 828: if (n[828]++ > 0) check ('a string 828'); break;
    case 829: if (n[829]++ > 0) check ('a string 829'); break;
    case 830: if (n[830]++ > 0) check ('a string 830'); break;
    case 831: if (n[831]++ > 0) check ('a string 831'); break;
    case 832: if (n[832]++ > 0) check ('a string 832'); break;
    case 833: if (n[833]++ > 0) check ('a string 833'); break;
    case 834: if (n[834]++ > 0) check ('a string 834'); break;
    case 835: if (n[835]++ > 0) check ('a string 835'); break;
    case 836: if (n[836]++ > 0) check ('a string 836'); break;
    case 837: if (n[837]++ > 0) check ('a string 837'); break;
    case 838: if (n[838]++ > 0) check ('a string 838'); break;
    case 839: if (n[839]++ > 0) check ('a string 839'); break;
    case 840: if (n[840]++ > 0) check ('a string 840'); break;
    case 841: if (n[841]++ > 0) check ('a string 841'); break;
    case 842: if (n[842]++ > 0) check ('a string 842'); break;
    case 843: if (n[843]++ > 0) check ('a string 843'); break;
    case 844: if (n[844]++ > 0) check ('a string 844'); break;
    case 845: if (n[845]++ > 0) check ('a string 845'); break;
    case 846: if (n[846]++ > 0) check ('a string 846'); break;
    case 847: if (n[847]++ > 0) check ('a string 847'); break;
    case 848: if (n[848]++ > 0) check ('a string 848'); break;
    case 849: if (n[849]++ > 0) check ('a string 849'); break;
    case 850: if (n[850]++ > 0) check ('a string 850'); break;
    case 851: if (n[851]++ > 0) check ('a string 851'); break;
    case 852: if (n[852]++ > 0) check ('a string 852'); break;
    case 853: if (n[853]++ > 0) check ('a string 853'); break;
    case 854: if (n[854]++ > 0) check ('a string 854'); break;
    case 855: if (n[855]++ > 0) check ('a string 855'); break;
    case 856: if (n[856]++ > 0) check ('a string 856'); break;
    case 857: if (n[857]++ > 0) check ('a string 857'); break;
    case 858: if (n[858]++ > 0) check ('a string 858'); break;
    case 859: if (n[859]++ > 0) check ('a string 859'); break;
    case 860: if (n[860]++ > 0) check ('a string 860'); break;
    case 861: if (n[861]++ > 0) check ('a string 861'); break;
    case 862: if (n[862]++ > 0) check ('a string 862'); break;
    case 863: if (n[863]++ > 0) check ('a string 863'); break;
    case 864: if (n[864]++ > 0) check ('a string 864'); break;
    case 865: if (n[865]++ > 0) check ('a string 865'); break;
    case 866: if (n[866]++ > 0) check ('a string 866'); break;
    case 867: if (n[867]++ > 0) check ('a string 867'); break;
    case 868: if (n[868]++ > 0) check ('a string 868'); break;
    case 869: if (n[869]++ > 0) check ('a string 869'); break;
    case 870: if (n[870]++ > 0) check ('a string 870'); break;
    case 871: if (n[871]++ > 0) check ('a string 871'); break;
    case 872: if (n[872]++ > 0) check ('a string 872'); break;
    case 873: if (n[873]++ > 0) check ('a string 873'); break;
    case 874: if (n[874]++ > 0) check ('a string 874'); break;
    case 875: if (n[875]++ > 0) check ('a string 875'); break;
    case 876: if (n[876]++ > 0) check ('a string 876'); break;
    case 877: if (n[877]++ > 0) check ('a string 877'); break;
    case 878: if (n[878]++ > 0) check ('a string 878'); break;
    case 879: if (n[879]++ > 0) check ('a string 879'); break;
    case 880: if (n[880]++ > 0) check ('a string 880'); break;
    case 881: if (n[881]++ > 0) check ('a string 881'); break;
    case 882: if (n[882]++ > 0) check ('a string 882'); break;
    case 883: if (n[883]++ > 0) check ('a string 883'); break;
    case 884: if (n[884]++ > 0) check ('a string 884'); break;
    case 885: if (n[885]++ > 0) check ('a string 885'); break;
    case 886: if (n[886]++ > 0) check ('a string 886'); break;
    case 887: if (n[887]++ > 0) check ('a string 887'); break;
    case 888: if (n[888]++ > 0) check ('a string 888'); break;
    case 889: if (n[889]++ > 0) check ('a string 889'); break;
    case 890: if (n[890]++ > 0) check ('a string 890'); break;
    case 891: if (n[891]++ > 0) check ('a string 891'); break;
    case 892: if (n[892]++ > 0) check ('a string 892'); break;
    case 893: if (n[893]++ > 0) check ('a string 893'); break;
    case 894: if (n[894]++ > 0) check ('a string 894'); break;
    case 895: if (n[895]++ > 0) check ('a string 895'); break;
    case 896: if (n[896]++ > 0) check ('a string 896'); break;
    case 897: if (n[897]++ > 0) check ('a string 897'); break;
    case 898: if (n[898]++ > 0) check ('a string 898'); break;
    case 899: if (n[899]++ > 0) check ('a string 899'); break;
    case 900: if (n[900]++ > 0) check ('a string 900'); break;
    case 901: if (n[901]++ > 0) check ('a string 901'); break;
    case 902: if (n[902]++ > 0) check ('a string 902'); break;
    case 903: if (n[903]++ > 0) check ('a string 903'); break;
    case 904: if (n[904]++ > 0) check ('a string 904'); break;
    case 905: if (n[905]++ > 0) check ('a string 905'); break;
    case 906: if (n[906]++ > 0) check ('a string 906'); break;
    case 907: if (n[907]++ > 0) check ('a string 907'); break;
    case 908: if (n[908]++ > 0) check ('a string 908'); break;
    case 909: if (n[909]++ > 0) check ('a string 909'); break;
    case 910: if (n[910]++ > 0) check ('a string 910'); break;
    case 911: if (n[911]++ > 0) check ('a string 911'); break;
    case 912: if (n[912]++ > 0) check ('a string 912'); break;
    case 913: if (n[913]++ > 0) check ('a string 913'); break;
    case 914: if (n[914]++ > 0) check ('a string 914'); break;
    case 915: if (n[915]++ > 0) check ('a string 915'); break;
    case 916: if (n[916]++ > 0) check ('a string 916'); break;
    case 917: if (n[917]++ > 0) check ('a string 917'); break;
    case 918: if (n[918]++ > 0) check ('a string 918'); break;
    case 919: if (n[919]++ > 0) check ('a string 919'); break;
    case 920: if (n[920]++ > 0) check ('a string 920'); break;
    case 921: if (n[921]++ > 0) check ('a string 921'); break;
    case 922: if (n[922]++ > 0) check ('a string 922'); break;
    case 923: if (n[923]++ > 0) check ('a string 923'); break;
    case 924: if (n[924]++ > 0) check ('a string 924'); break;
    case 925: if (n[925]++ > 0) check ('a string 925'); break;
    case 926: if (n[926]++ > 0) check ('a string 926'); break;
    case 927: if (n[927]++ > 0) check ('a string 927'); break;
    case 928: if (n[928]++ > 0) check ('a string 928'); break;
    case 929: if (n[929]++ > 0) check ('a string 929'); break;
    case 930: if (n[930]++ > 0) check ('a string 930'); break;
    case 931: if (n[931]++ > 0) check ('a string 931'); break;
    case 932: if (n[932]++ > 0) check ('a string 932'); break;
    case 933: if (n[933]++ > 0) check ('a string 933'); break;
    case 934: if (n[934]++ > 0) check ('a string 934'); break;
    case 935: if (n[935]++ > 0) check ('a string 935'); break;
    case 936: if (n[936]++ > 0) check ('a string 936'); break;
    case 937: if (n[937]++ > 0) check ('a string 937'); break;
    case 938: if (n[938]++ > 0) check ('a string 938'); break;
    case 939: if (n[939]++ > 0) check ('a string 939'); break;
    case 940: if (n[940]++ > 0) check ('a string 940'); break;
    case 941: if (n[941]++ > 0) check ('a string 941'); break;
    case 942: if (n[942]++ > 0) check ('a string 942'); break;
    case 943: if (n[943]++ > 0) check ('a string 943'); break;
    case 944: if (n[944]++ > 0) check ('a string 944'); break;
    case 945: if (n[945]++ > 0) check ('a string 945'); break;
    case 946: if (n[946]++ > 0) check ('a string 946'); break;
    case 947: if (n[947]++ > 0) check ('a string 947'); break;
    case 948: if (n[948]++ > 0) check ('a string 948'); break;
    case 949: if (n[949]++ > 0) check ('a string 949'); break;
    case 950: if (n[950]++ > 0) check ('a string 950'); break;
    case 951: if (n[951]++ > 0) check ('a string 951'); break;
    case 952: if (n[952]++ > 0) check ('a string 952'); break;
    case 953: if (n[953]++ > 0) check ('a string 953'); break;
    case 954: if (n[954]++ > 0) check ('a string 954'); break;
    case 955: if (n[955]++ > 0) check ('a string 955'); break;
    case 956: if (n[956]++ > 0) check ('a string 956'); break;
    case 957: if (n[957]++ > 0) check ('a string 957'); break;
    case 958: if (n[958]++ > 0) check ('a string 958'); break;
    case 959: if (n[959]++ > 0) check ('a string 959'); break;
    case 960: if (n[960]++ > 0) check ('a string 960'); break;
    case 961: if (n[961]++ > 0) check ('a string 961'); break;
    case 962: if (n[962]++ > 0) check ('a string 962'); break;
    case 963: if (n[963]++ > 0) check ('a string 963'); break;
    case 964: if (n[964]++ > 0) check ('a string 964'); break;
    case 965: if (n[965]++ > 0) check ('a string 965'); break;
    case 966: if (n[966]++ > 0) check ('a string 966'); break;
    case 967: if (n[967]++ > 0) check ('a string 967'); break;
    case 968: if (n[968]++ > 0) check ('a string 968'); break;
    case 969: if (n[969]++ > 0) check ('a string 969'); break;
    case 970: if (n[970]++ > 0) check ('a string 970'); break;
    case 971: if (n[971]++ > 0) check ('a string 971'); break;
    case 972: if (n[972]++ > 0) check ('a string 972'); break;
    case 973: if (n[973]++ > 0) check ('a string 973'); break;
    case 974: if (n[974]++ > 0) check ('a string 974'); break;
    case 975: if (n[975]++ > 0) check ('a string 975'); break;
    case 976: if (n[976]++ > 0) check ('a string 976'); break;
    case 977: if (n[977]++ > 0) check ('a string 977'); break;
    case 978: if (n[978]++ > 0) check ('a string 978'); break;
    case 979: if (n[979]++ > 0) check ('a string 979'); break;
    case 980: if (n[980]++ > 0) check ('a string 980'); break;
    case 981: if (n[981]++ > 0) check ('a string 981'); break;
    case 982: if (n[982]++ > 0) check ('a string 982'); break;
    case 983: if (n[983]++ > 0) check ('a string 983'); break;
    case 984: if (n[984]++ > 0) check ('a string 984'); break;
    case 985: if (n[985]++ > 0) check ('a string 985'); break;
    case 986: if (n[986]++ > 0) check ('a string 986'); break;
    case 987: if (n[987]++ > 0) check ('a string 987'); break;
    case 988: if (n[988]++ > 0) check ('a string 988'); break;
    case 989: if (n[989]++ > 0) check ('a string 989'); break;
    case 990: if (n[990]++ > 0) check ('a string 990'); break;
    case 991: if (n[991]++ > 0) check ('a string 991'); break;
    case 992: if (n[992]++ > 0) check ('a string 992'); break;
    case 993: if (n[993]++ > 0) check ('a string 993'); break;
    case 994: if (n[994]++ > 0) check ('a string 994'); break;
    case 995: if (n[995]++ > 0) check ('a string 995'); break;
    case 996: if (n[996]++ > 0) check ('a string 996'); break;
    case 997: if (n[997]++ > 0) check ('a string 997'); break;
    case 998: if (n[998]++ > 0) check ('a string 998'); break;
    case 999: if (n[999]++ > 0) check ('a string 999'); break;
    case 1000: if (n[1000]++ > 0) check ('a string 1000'); break;
    case 1001: if (n[1001]++ > 0) check ('a string 1001'); break;
    case 1002: if (n[1002]++ > 0) check ('a string 1002'); break;
    case 1003: if (n[1003]++ > 0) check ('a string 1003'); break;
    case 1004: if (n[1004]++ > 0) check ('a string 1004'); break;
    case 1005: if (n[1005]++ > 0) check ('a string 1005'); break;
    case 1006: if (n[1006]++ > 0) check ('a string 1006'); break;
    case 1007: if (n[1007]++ > 0) check ('a string 1007'); break;
    case 1008: if (n[1008]++ > 0) check ('a string 1008'); break;
    case 1009: if (n[1009]++ > 0) check ('a string 1009'); break;
    case 1010: if (n[1010]++ > 0) check ('a string 1010'); break;
    case 1011: if (n[1011]++ > 0) check ('a string 1011'); break;
    case 1012: if (n[1012]++ > 0) check ('a string 1012'); break;
    case 1013: if (n[1013]++ > 0) check ('a string 1013'); break;
    case 1014: if (n[1014]++ > 0) check ('a string 1014'); break;
    case 1015: if (n[1015]++ > 0) check ('a string 1015'); break;
--> --------------------

--> maximum size reached

--> --------------------