PageRenderTime 61ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 0ms

/JavaScriptCore/tests/mozilla/js1_5/Regress/regress-80981.js

http://github.com/CyanogenMod/android_external_webkit
JavaScript | 1024 lines | 959 code | 8 blank | 57 comment | 939 complexity | 99c489f588acc556708b4454e0305c63 MD5 | raw file
Possible License(s): LGPL-2.0, BSD-3-Clause, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. /* ***** BEGIN LICENSE BLOCK *****
    2. 

  2. * Version: NPL 1.1/GPL 2.0/LGPL 2.1
    3. 

  3. *
    4. 

  4. * The contents of this file are subject to the Netscape Public License
    5. 

  5. * Version 1.1 (the "License"); you may not use this file except in
    6. 

  6. * compliance with the License. You may obtain a copy of the License at
    7. 

  7. * http://www.mozilla.org/NPL/
    8. 

  8. *
    9. 

  9. * Software distributed under the License is distributed on an "AS IS" basis,
    10. 

  10. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    11. 

  11. * for the specific language governing rights and limitations under the
    12. 

  12. * License.
    13. 

  13. *
    14. 

  14. * The Original Code is JavaScript Engine testing utilities.
    15. 

  15. *
    16. 

  16. * The Initial Developer of the Original Code is Netscape Communications Corp.
    17. 

  17. * Portions created by the Initial Developer are Copyright (C) 2001
    18. 

  18. * the Initial Developer. All Rights Reserved.
    19. 

  19. *
    20. 

  20. * Contributor(s): khanson@netscape.com
    21. 

  21. *
    22. 

  22. * Alternatively, the contents of this file may be used under the terms of
    23. 

  23. * either the GNU General Public License Version 2 or later (the "GPL"), or
    24. 

  24. * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
    25. 

  25. * in which case the provisions of the GPL or the LGPL are applicable instead
    26. 

  26. * of those above. If you wish to allow use of your version of this file only
    27. 

  27. * under the terms of either the GPL or the LGPL, and not to allow others to
    28. 

  28. * use your version of this file under the terms of the NPL, indicate your
    29. 

  29. * decision by deleting the provisions above and replace them with the notice
    30. 

  30. * and other provisions required by the GPL or the LGPL. If you do not delete
    31. 

  31. * the provisions above, a recipient may use your version of this file under
    32. 

  32. * the terms of any one of the NPL, the GPL or the LGPL.
    33. 

  33. *
    34. 

  34. * ***** END LICENSE BLOCK *****
    35. 

  35. *
    36. 

  36. *
    37. 

  37. * Date: 19 Nov 2001
    38. 

  38. * SUMMARY: Regression test for bug 80981.
    39. 

  39. * See http://bugzilla.mozilla.org/show_bug.cgi?id=80981
    40. 

  40. * "Need extended jump bytecode to avoid "script too large" errors, etc."
    41. 

  41. *
    42. 

  42. * Before this bug was fixed, the script below caused a run-time error because
    43. 

  43. * its switch statement was too big. After the fix, SpiderMonkey should compile
    44. 

  44. * this script just fine. The same fix has not been made in Rhino, however,
    45. 

  45. * so it will continue to error there...
    46. 

  46. *
    47. 

  47. * If you ever run this test against an old SpiderMonkey shell to see the bug,
    48. 

  48. * you should run it interactively: i.e. launch the JS shell manually, and load
    49. 

  49. * the test manually. Do not run it via the test driver jsDriverl.pl. Why? -
    50. 

  50. * before the fix for bug 97646, the JS shell would error on this script, but
    51. 

  51. * would NOT give non-0 exit code. As a result, the test driver couldn't detect
    52. 

  52. * the error (it looks for non-0 exit codes).
    53. 

  53. *
    54. 

  54. */
    55. 

  55. //-----------------------------------------------------------------------------
    56. 

  56. var i2 = 3011;
    57. 

  57. var n = new Array (i2);
    58. 

  58. var err_num = 0;
    59. 

  59. var i = 0;
    60. 

  60. var j = 0;
    61. 

  61. var k = 0;
    62. 

  62. 

  63. 

  64. //-----------------------------------------------------------------------------
    65. 

  65. test();
    66. 

  66. //-----------------------------------------------------------------------------
    67. 

  67. 

  68. 

  69. function test()
    70. 

  70. {
    71. 

  71.   b ();
    72. 

  72.   b4 ();
    73. 

  73.   print('Number of errors = ' + err_num);
    74. 

  74. }
    75. 

  75. 

  76. 

  77. function b() 
    78. 

  78. {
    79. 

  79.   b4 ();
    80. 

  80.   b_after ();
    81. 

  81. 

  82.   for (i=0; i<i2; i++) {n[i] = 0;}
    83. 

  83.   i = 0;
    84. 

  84.   
    85. 

  85.   while (k++ <= i2)
    86. 

  86.   {
    87. 

  87.     switch (j = (k*73)%i2) 
    88. 

  88.     {
    89. 

  89.         case 0: if (n[0]++ > 0) check ('a string 0'); break;
    90. 

  90.         case 1: if (n[1]++ > 0) check ('a string 1'); break;
    91. 

  91.         case 2: if (n[2]++ > 0) check ('a string 2'); break;
    92. 

  92.         case 3: if (n[3]++ > 0) check ('a string 3'); break;
    93. 

  93.         case 4: if (n[4]++ > 0) check ('a string 4'); break;
    94. 

  94.         case 5: if (n[5]++ > 0) check ('a string 5'); break;
    95. 

  95.         case 6: if (n[6]++ > 0) check ('a string 6'); break;
    96. 

  96.         case 7: if (n[7]++ > 0) check ('a string 7'); break;
    97. 

  97.         case 8: if (n[8]++ > 0) check ('a string 8'); break;
    98. 

  98.         case 9: if (n[9]++ > 0) check ('a string 9'); break;
    99. 

  99.         case 10: if (n[10]++ > 0) check ('a string 10'); break;
    100. 

  100.         case 11: if (n[11]++ > 0) check ('a string 11'); break;
    101. 

  101.         case 12: if (n[12]++ > 0) check ('a string 12'); break;
    102. 

  102.         case 13: if (n[13]++ > 0) check ('a string 13'); break;
    103. 

  103.         case 14: if (n[14]++ > 0) check ('a string 14'); break;
    104. 

  104.         case 15: if (n[15]++ > 0) check ('a string 15'); break;
    105. 

  105.         case 16: if (n[16]++ > 0) check ('a string 16'); break;
    106. 

  106.         case 17: if (n[17]++ > 0) check ('a string 17'); break;
    107. 

  107.         case 18: if (n[18]++ > 0) check ('a string 18'); break;
    108. 

  108.         case 19: if (n[19]++ > 0) check ('a string 19'); break;
    109. 

  109.         case 20: if (n[20]++ > 0) check ('a string 20'); break;
    110. 

  110.         case 21: if (n[21]++ > 0) check ('a string 21'); break;
    111. 

  111.         case 22: if (n[22]++ > 0) check ('a string 22'); break;
    112. 

  112.         case 23: if (n[23]++ > 0) check ('a string 23'); break;
    113. 

  113.         case 24: if (n[24]++ > 0) check ('a string 24'); break;
    114. 

  114.         case 25: if (n[25]++ > 0) check ('a string 25'); break;
    115. 

  115.         case 26: if (n[26]++ > 0) check ('a string 26'); break;
    116. 

  116.         case 27: if (n[27]++ > 0) check ('a string 27'); break;
    117. 

  117.         case 28: if (n[28]++ > 0) check ('a string 28'); break;
    118. 

  118.         case 29: if (n[29]++ > 0) check ('a string 29'); break;
    119. 

  119.         case 30: if (n[30]++ > 0) check ('a string 30'); break;
    120. 

  120.         case 31: if (n[31]++ > 0) check ('a string 31'); break;
    121. 

  121.         case 32: if (n[32]++ > 0) check ('a string 32'); break;
    122. 

  122.         case 33: if (n[33]++ > 0) check ('a string 33'); break;
    123. 

  123.         case 34: if (n[34]++ > 0) check ('a string 34'); break;
    124. 

  124.         case 35: if (n[35]++ > 0) check ('a string 35'); break;
    125. 

  125.         case 36: if (n[36]++ > 0) check ('a string 36'); break;
    126. 

  126.         case 37: if (n[37]++ > 0) check ('a string 37'); break;
    127. 

  127.         case 38: if (n[38]++ > 0) check ('a string 38'); break;
    128. 

  128.         case 39: if (n[39]++ > 0) check ('a string 39'); break;
    129. 

  129.         case 40: if (n[40]++ > 0) check ('a string 40'); break;
    130. 

  130.         case 41: if (n[41]++ > 0) check ('a string 41'); break;
    131. 

  131.         case 42: if (n[42]++ > 0) check ('a string 42'); break;
    132. 

  132.         case 43: if (n[43]++ > 0) check ('a string 43'); break;
    133. 

  133.         case 44: if (n[44]++ > 0) check ('a string 44'); break;
    134. 

  134.         case 45: if (n[45]++ > 0) check ('a string 45'); break;
    135. 

  135.         case 46: if (n[46]++ > 0) check ('a string 46'); break;
    136. 

  136.         case 47: if (n[47]++ > 0) check ('a string 47'); break;
    137. 

  137.         case 48: if (n[48]++ > 0) check ('a string 48'); break;
    138. 

  138.         case 49: if (n[49]++ > 0) check ('a string 49'); break;
    139. 

  139.         case 50: if (n[50]++ > 0) check ('a string 50'); break;
    140. 

  140.         case 51: if (n[51]++ > 0) check ('a string 51'); break;
    141. 

  141.         case 52: if (n[52]++ > 0) check ('a string 52'); break;
    142. 

  142.         case 53: if (n[53]++ > 0) check ('a string 53'); break;
    143. 

  143.         case 54: if (n[54]++ > 0) check ('a string 54'); break;
    144. 

  144.         case 55: if (n[55]++ > 0) check ('a string 55'); break;
    145. 

  145.         case 56: if (n[56]++ > 0) check ('a string 56'); break;
    146. 

  146.         case 57: if (n[57]++ > 0) check ('a string 57'); break;
    147. 

  147.         case 58: if (n[58]++ > 0) check ('a string 58'); break;
    148. 

  148.         case 59: if (n[59]++ > 0) check ('a string 59'); break;
    149. 

  149.         case 60: if (n[60]++ > 0) check ('a string 60'); break;
    150. 

  150.         case 61: if (n[61]++ > 0) check ('a string 61'); break;
    151. 

  151.         case 62: if (n[62]++ > 0) check ('a string 62'); break;
    152. 

  152.         case 63: if (n[63]++ > 0) check ('a string 63'); break;
    153. 

  153.         case 64: if (n[64]++ > 0) check ('a string 64'); break;
    154. 

  154.         case 65: if (n[65]++ > 0) check ('a string 65'); break;
    155. 

  155.         case 66: if (n[66]++ > 0) check ('a string 66'); break;
    156. 

  156.         case 67: if (n[67]++ > 0) check ('a string 67'); break;
    157. 

  157.         case 68: if (n[68]++ > 0) check ('a string 68'); break;
    158. 

  158.         case 69: if (n[69]++ > 0) check ('a string 69'); break;
    159. 

  159.         case 70: if (n[70]++ > 0) check ('a string 70'); break;
    160. 

  160.         case 71: if (n[71]++ > 0) check ('a string 71'); break;
    161. 

  161.         case 72: if (n[72]++ > 0) check ('a string 72'); break;
    162. 

  162.         case 73: if (n[73]++ > 0) check ('a string 73'); break;
    163. 

  163.         case 74: if (n[74]++ > 0) check ('a string 74'); break;
    164. 

  164.         case 75: if (n[75]++ > 0) check ('a string 75'); break;
    165. 

  165.         case 76: if (n[76]++ > 0) check ('a string 76'); break;
    166. 

  166.         case 77: if (n[77]++ > 0) check ('a string 77'); break;
    167. 

  167.         case 78: if (n[78]++ > 0) check ('a string 78'); break;
    168. 

  168.         case 79: if (n[79]++ > 0) check ('a string 79'); break;
    169. 

  169.         case 80: if (n[80]++ > 0) check ('a string 80'); break;
    170. 

  170.         case 81: if (n[81]++ > 0) check ('a string 81'); break;
    171. 

  171.         case 82: if (n[82]++ > 0) check ('a string 82'); break;
    172. 

  172.         case 83: if (n[83]++ > 0) check ('a string 83'); break;
    173. 

  173.         case 84: if (n[84]++ > 0) check ('a string 84'); break;
    174. 

  174.         case 85: if (n[85]++ > 0) check ('a string 85'); break;
    175. 

  175.         case 86: if (n[86]++ > 0) check ('a string 86'); break;
    176. 

  176.         case 87: if (n[87]++ > 0) check ('a string 87'); break;
    177. 

  177.         case 88: if (n[88]++ > 0) check ('a string 88'); break;
    178. 

  178.         case 89: if (n[89]++ > 0) check ('a string 89'); break;
    179. 

  179.         case 90: if (n[90]++ > 0) check ('a string 90'); break;
    180. 

  180.         case 91: if (n[91]++ > 0) check ('a string 91'); break;
    181. 

  181.         case 92: if (n[92]++ > 0) check ('a string 92'); break;
    182. 

  182.         case 93: if (n[93]++ > 0) check ('a string 93'); break;
    183. 

  183.         case 94: if (n[94]++ > 0) check ('a string 94'); break;
    184. 

  184.         case 95: if (n[95]++ > 0) check ('a string 95'); break;
    185. 

  185.         case 96: if (n[96]++ > 0) check ('a string 96'); break;
    186. 

  186.         case 97: if (n[97]++ > 0) check ('a string 97'); break;
    187. 

  187.         case 98: if (n[98]++ > 0) check ('a string 98'); break;
    188. 

  188.         case 99: if (n[99]++ > 0) check ('a string 99'); break;
    189. 

  189.         case 100: if (n[100]++ > 0) check ('a string 100'); break;
    190. 

  190.         case 101: if (n[101]++ > 0) check ('a string 101'); break;
    191. 

  191.         case 102: if (n[102]++ > 0) check ('a string 102'); break;
    192. 

  192.         case 103: if (n[103]++ > 0) check ('a string 103'); break;
    193. 

  193.         case 104: if (n[104]++ > 0) check ('a string 104'); break;
    194. 

  194.         case 105: if (n[105]++ > 0) check ('a string 105'); break;
    195. 

  195.         case 106: if (n[106]++ > 0) check ('a string 106'); break;
    196. 

  196.         case 107: if (n[107]++ > 0) check ('a string 107'); break;
    197. 

  197.         case 108: if (n[108]++ > 0) check ('a string 108'); break;
    198. 

  198.         case 109: if (n[109]++ > 0) check ('a string 109'); break;
    199. 

  199.         case 110: if (n[110]++ > 0) check ('a string 110'); break;
    200. 

  200.         case 111: if (n[111]++ > 0) check ('a string 111'); break;
    201. 

  201.         case 112: if (n[112]++ > 0) check ('a string 112'); break;
    202. 

  202.         case 113: if (n[113]++ > 0) check ('a string 113'); break;
    203. 

  203.         case 114: if (n[114]++ > 0) check ('a string 114'); break;
    204. 

  204.         case 115: if (n[115]++ > 0) check ('a string 115'); break;
    205. 

  205.         case 116: if (n[116]++ > 0) check ('a string 116'); break;
    206. 

  206.         case 117: if (n[117]++ > 0) check ('a string 117'); break;
    207. 

  207.         case 118: if (n[118]++ > 0) check ('a string 118'); break;
    208. 

  208.         case 119: if (n[119]++ > 0) check ('a string 119'); break;
    209. 

  209.         case 120: if (n[120]++ > 0) check ('a string 120'); break;
    210. 

  210.         case 121: if (n[121]++ > 0) check ('a string 121'); break;
    211. 

  211.         case 122: if (n[122]++ > 0) check ('a string 122'); break;
    212. 

  212.         case 123: if (n[123]++ > 0) check ('a string 123'); break;
    213. 

  213.         case 124: if (n[124]++ > 0) check ('a string 124'); break;
    214. 

  214.         case 125: if (n[125]++ > 0) check ('a string 125'); break;
    215. 

  215.         case 126: if (n[126]++ > 0) check ('a string 126'); break;
    216. 

  216.         case 127: if (n[127]++ > 0) check ('a string 127'); break;
    217. 

  217.         case 128: if (n[128]++ > 0) check ('a string 128'); break;
    218. 

  218.         case 129: if (n[129]++ > 0) check ('a string 129'); break;
    219. 

  219.         case 130: if (n[130]++ > 0) check ('a string 130'); break;
    220. 

  220.         case 131: if (n[131]++ > 0) check ('a string 131'); break;
    221. 

  221.         case 132: if (n[132]++ > 0) check ('a string 132'); break;
    222. 

  222.         case 133: if (n[133]++ > 0) check ('a string 133'); break;
    223. 

  223.         case 134: if (n[134]++ > 0) check ('a string 134'); break;
    224. 

  224.         case 135: if (n[135]++ > 0) check ('a string 135'); break;
    225. 

  225.         case 136: if (n[136]++ > 0) check ('a string 136'); break;
    226. 

  226.         case 137: if (n[137]++ > 0) check ('a string 137'); break;
    227. 

  227.         case 138: if (n[138]++ > 0) check ('a string 138'); break;
    228. 

  228.         case 139: if (n[139]++ > 0) check ('a string 139'); break;
    229. 

  229.         case 140: if (n[140]++ > 0) check ('a string 140'); break;
    230. 

  230.         case 141: if (n[141]++ > 0) check ('a string 141'); break;
    231. 

  231.         case 142: if (n[142]++ > 0) check ('a string 142'); break;
    232. 

  232.         case 143: if (n[143]++ > 0) check ('a string 143'); break;
    233. 

  233.         case 144: if (n[144]++ > 0) check ('a string 144'); break;
    234. 

  234.         case 145: if (n[145]++ > 0) check ('a string 145'); break;
    235. 

  235.         case 146: if (n[146]++ > 0) check ('a string 146'); break;
    236. 

  236.         case 147: if (n[147]++ > 0) check ('a string 147'); break;
    237. 

  237.         case 148: if (n[148]++ > 0) check ('a string 148'); break;
    238. 

  238.         case 149: if (n[149]++ > 0) check ('a string 149'); break;
    239. 

  239.         case 150: if (n[150]++ > 0) check ('a string 150'); break;
    240. 

  240.         case 151: if (n[151]++ > 0) check ('a string 151'); break;
    241. 

  241.         case 152: if (n[152]++ > 0) check ('a string 152'); break;
    242. 

  242.         case 153: if (n[153]++ > 0) check ('a string 153'); break;
    243. 

  243.         case 154: if (n[154]++ > 0) check ('a string 154'); break;
    244. 

  244.         case 155: if (n[155]++ > 0) check ('a string 155'); break;
    245. 

  245.         case 156: if (n[156]++ > 0) check ('a string 156'); break;
    246. 

  246.         case 157: if (n[157]++ > 0) check ('a string 157'); break;
    247. 

  247.         case 158: if (n[158]++ > 0) check ('a string 158'); break;
    248. 

  248.         case 159: if (n[159]++ > 0) check ('a string 159'); break;
    249. 

  249.         case 160: if (n[160]++ > 0) check ('a string 160'); break;
    250. 

  250.         case 161: if (n[161]++ > 0) check ('a string 161'); break;
    251. 

  251.         case 162: if (n[162]++ > 0) check ('a string 162'); break;
    252. 

  252.         case 163: if (n[163]++ > 0) check ('a string 163'); break;
    253. 

  253.         case 164: if (n[164]++ > 0) check ('a string 164'); break;
    254. 

  254.         case 165: if (n[165]++ > 0) check ('a string 165'); break;
    255. 

  255.         case 166: if (n[166]++ > 0) check ('a string 166'); break;
    256. 

  256.         case 167: if (n[167]++ > 0) check ('a string 167'); break;
    257. 

  257.         case 168: if (n[168]++ > 0) check ('a string 168'); break;
    258. 

  258.         case 169: if (n[169]++ > 0) check ('a string 169'); break;
    259. 

  259.         case 170: if (n[170]++ > 0) check ('a string 170'); break;
    260. 

  260.         case 171: if (n[171]++ > 0) check ('a string 171'); break;
    261. 

  261.         case 172: if (n[172]++ > 0) check ('a string 172'); break;
    262. 

  262.         case 173: if (n[173]++ > 0) check ('a string 173'); break;
    263. 

  263.         case 174: if (n[174]++ > 0) check ('a string 174'); break;
    264. 

  264.         case 175: if (n[175]++ > 0) check ('a string 175'); break;
    265. 

  265.         case 176: if (n[176]++ > 0) check ('a string 176'); break;
    266. 

  266.         case 177: if (n[177]++ > 0) check ('a string 177'); break;
    267. 

  267.         case 178: if (n[178]++ > 0) check ('a string 178'); break;
    268. 

  268.         case 179: if (n[179]++ > 0) check ('a string 179'); break;
    269. 

  269.         case 180: if (n[180]++ > 0) check ('a string 180'); break;
    270. 

  270.         case 181: if (n[181]++ > 0) check ('a string 181'); break;
    271. 

  271.         case 182: if (n[182]++ > 0) check ('a string 182'); break;
    272. 

  272.         case 183: if (n[183]++ > 0) check ('a string 183'); break;
    273. 

  273.         case 184: if (n[184]++ > 0) check ('a string 184'); break;
    274. 

  274.         case 185: if (n[185]++ > 0) check ('a string 185'); break;
    275. 

  275.         case 186: if (n[186]++ > 0) check ('a string 186'); break;
    276. 

  276.         case 187: if (n[187]++ > 0) check ('a string 187'); break;
    277. 

  277.         case 188: if (n[188]++ > 0) check ('a string 188'); break;
    278. 

  278.         case 189: if (n[189]++ > 0) check ('a string 189'); break;
    279. 

  279.         case 190: if (n[190]++ > 0) check ('a string 190'); break;
    280. 

  280.         case 191: if (n[191]++ > 0) check ('a string 191'); break;
    281. 

  281.         case 192: if (n[192]++ > 0) check ('a string 192'); break;
    282. 

  282.         case 193: if (n[193]++ > 0) check ('a string 193'); break;
    283. 

  283.         case 194: if (n[194]++ > 0) check ('a string 194'); break;
    284. 

  284.         case 195: if (n[195]++ > 0) check ('a string 195'); break;
    285. 

  285.         case 196: if (n[196]++ > 0) check ('a string 196'); break;
    286. 

  286.         case 197: if (n[197]++ > 0) check ('a string 197'); break;
    287. 

  287.         case 198: if (n[198]++ > 0) check ('a string 198'); break;
    288. 

  288.         case 199: if (n[199]++ > 0) check ('a string 199'); break;
    289. 

  289.         case 200: if (n[200]++ > 0) check ('a string 200'); break;
    290. 

  290.         case 201: if (n[201]++ > 0) check ('a string 201'); break;
    291. 

  291.         case 202: if (n[202]++ > 0) check ('a string 202'); break;
    292. 

  292.         case 203: if (n[203]++ > 0) check ('a string 203'); break;
    293. 

  293.         case 204: if (n[204]++ > 0) check ('a string 204'); break;
    294. 

  294.         case 205: if (n[205]++ > 0) check ('a string 205'); break;
    295. 

  295.         case 206: if (n[206]++ > 0) check ('a string 206'); break;
    296. 

  296.         case 207: if (n[207]++ > 0) check ('a string 207'); break;
    297. 

  297.         case 208: if (n[208]++ > 0) check ('a string 208'); break;
    298. 

  298.         case 209: if (n[209]++ > 0) check ('a string 209'); break;
    299. 

  299.         case 210: if (n[210]++ > 0) check ('a string 210'); break;
    300. 

  300.         case 211: if (n[211]++ > 0) check ('a string 211'); break;
    301. 

  301.         case 212: if (n[212]++ > 0) check ('a string 212'); break;
    302. 

  302.         case 213: if (n[213]++ > 0) check ('a string 213'); break;
    303. 

  303.         case 214: if (n[214]++ > 0) check ('a string 214'); break;
    304. 

  304.         case 215: if (n[215]++ > 0) check ('a string 215'); break;
    305. 

  305.         case 216: if (n[216]++ > 0) check ('a string 216'); break;
    306. 

  306.         case 217: if (n[217]++ > 0) check ('a string 217'); break;
    307. 

  307.         case 218: if (n[218]++ > 0) check ('a string 218'); break;
    308. 

  308.         case 219: if (n[219]++ > 0) check ('a string 219'); break;
    309. 

  309.         case 220: if (n[220]++ > 0) check ('a string 220'); break;
    310. 

  310.         case 221: if (n[221]++ > 0) check ('a string 221'); break;
    311. 

  311.         case 222: if (n[222]++ > 0) check ('a string 222'); break;
    312. 

  312.         case 223: if (n[223]++ > 0) check ('a string 223'); break;
    313. 

  313.         case 224: if (n[224]++ > 0) check ('a string 224'); break;
    314. 

  314.         case 225: if (n[225]++ > 0) check ('a string 225'); break;
    315. 

  315.         case 226: if (n[226]++ > 0) check ('a string 226'); break;
    316. 

  316.         case 227: if (n[227]++ > 0) check ('a string 227'); break;
    317. 

  317.         case 228: if (n[228]++ > 0) check ('a string 228'); break;
    318. 

  318.         case 229: if (n[229]++ > 0) check ('a string 229'); break;
    319. 

  319.         case 230: if (n[230]++ > 0) check ('a string 230'); break;
    320. 

  320.         case 231: if (n[231]++ > 0) check ('a string 231'); break;
    321. 

  321.         case 232: if (n[232]++ > 0) check ('a string 232'); break;
    322. 

  322.         case 233: if (n[233]++ > 0) check ('a string 233'); break;
    323. 

  323.         case 234: if (n[234]++ > 0) check ('a string 234'); break;
    324. 

  324.         case 235: if (n[235]++ > 0) check ('a string 235'); break;
    325. 

  325.         case 236: if (n[236]++ > 0) check ('a string 236'); break;
    326. 

  326.         case 237: if (n[237]++ > 0) check ('a string 237'); break;
    327. 

  327.         case 238: if (n[238]++ > 0) check ('a string 238'); break;
    328. 

  328.         case 239: if (n[239]++ > 0) check ('a string 239'); break;
    329. 

  329.         case 240: if (n[240]++ > 0) check ('a string 240'); break;
    330. 

  330.         case 241: if (n[241]++ > 0) check ('a string 241'); break;
    331. 

  331.         case 242: if (n[242]++ > 0) check ('a string 242'); break;
    332. 

  332.         case 243: if (n[243]++ > 0) check ('a string 243'); break;
    333. 

  333.         case 244: if (n[244]++ > 0) check ('a string 244'); break;
    334. 

  334.         case 245: if (n[245]++ > 0) check ('a string 245'); break;
    335. 

  335.         case 246: if (n[246]++ > 0) check ('a string 246'); break;
    336. 

  336.         case 247: if (n[247]++ > 0) check ('a string 247'); break;
    337. 

  337.         case 248: if (n[248]++ > 0) check ('a string 248'); break;
    338. 

  338.         case 249: if (n[249]++ > 0) check ('a string 249'); break;
    339. 

  339.         case 250: if (n[250]++ > 0) check ('a string 250'); break;
    340. 

  340.         case 251: if (n[251]++ > 0) check ('a string 251'); break;
    341. 

  341.         case 252: if (n[252]++ > 0) check ('a string 252'); break;
    342. 

  342.         case 253: if (n[253]++ > 0) check ('a string 253'); break;
    343. 

  343.         case 254: if (n[254]++ > 0) check ('a string 254'); break;
    344. 

  344.         case 255: if (n[255]++ > 0) check ('a string 255'); break;
    345. 

  345.         case 256: if (n[256]++ > 0) check ('a string 256'); break;
    346. 

  346.         case 257: if (n[257]++ > 0) check ('a string 257'); break;
    347. 

  347.         case 258: if (n[258]++ > 0) check ('a string 258'); break;
    348. 

  348.         case 259: if (n[259]++ > 0) check ('a string 259'); break;
    349. 

  349.         case 260: if (n[260]++ > 0) check ('a string 260'); break;
    350. 

  350.         case 261: if (n[261]++ > 0) check ('a string 261'); break;
    351. 

  351.         case 262: if (n[262]++ > 0) check ('a string 262'); break;
    352. 

  352.         case 263: if (n[263]++ > 0) check ('a string 263'); break;
    353. 

  353.         case 264: if (n[264]++ > 0) check ('a string 264'); break;
    354. 

  354.         case 265: if (n[265]++ > 0) check ('a string 265'); break;
    355. 

  355.         case 266: if (n[266]++ > 0) check ('a string 266'); break;
    356. 

  356.         case 267: if (n[267]++ > 0) check ('a string 267'); break;
    357. 

  357.         case 268: if (n[268]++ > 0) check ('a string 268'); break;
    358. 

  358.         case 269: if (n[269]++ > 0) check ('a string 269'); break;
    359. 

  359.         case 270: if (n[270]++ > 0) check ('a string 270'); break;
    360. 

  360.         case 271: if (n[271]++ > 0) check ('a string 271'); break;
    361. 

  361.         case 272: if (n[272]++ > 0) check ('a string 272'); break;
    362. 

  362.         case 273: if (n[273]++ > 0) check ('a string 273'); break;
    363. 

  363.         case 274: if (n[274]++ > 0) check ('a string 274'); break;
    364. 

  364.         case 275: if (n[275]++ > 0) check ('a string 275'); break;
    365. 

  365.         case 276: if (n[276]++ > 0) check ('a string 276'); break;
    366. 

  366.         case 277: if (n[277]++ > 0) check ('a string 277'); break;
    367. 

  367.         case 278: if (n[278]++ > 0) check ('a string 278'); break;
    368. 

  368.         case 279: if (n[279]++ > 0) check ('a string 279'); break;
    369. 

  369.         case 280: if (n[280]++ > 0) check ('a string 280'); break;
    370. 

  370.         case 281: if (n[281]++ > 0) check ('a string 281'); break;
    371. 

  371.         case 282: if (n[282]++ > 0) check ('a string 282'); break;
    372. 

  372.         case 283: if (n[283]++ > 0) check ('a string 283'); break;
    373. 

  373.         case 284: if (n[284]++ > 0) check ('a string 284'); break;
    374. 

  374.         case 285: if (n[285]++ > 0) check ('a string 285'); break;
    375. 

  375.         case 286: if (n[286]++ > 0) check ('a string 286'); break;
    376. 

  376.         case 287: if (n[287]++ > 0) check ('a string 287'); break;
    377. 

  377.         case 288: if (n[288]++ > 0) check ('a string 288'); break;
    378. 

  378.         case 289: if (n[289]++ > 0) check ('a string 289'); break;
    379. 

  379.         case 290: if (n[290]++ > 0) check ('a string 290'); break;
    380. 

  380.         case 291: if (n[291]++ > 0) check ('a string 291'); break;
    381. 

  381.         case 292: if (n[292]++ > 0) check ('a string 292'); break;
    382. 

  382.         case 293: if (n[293]++ > 0) check ('a string 293'); break;
    383. 

  383.         case 294: if (n[294]++ > 0) check ('a string 294'); break;
    384. 

  384.         case 295: if (n[295]++ > 0) check ('a string 295'); break;
    385. 

  385.         case 296: if (n[296]++ > 0) check ('a string 296'); break;
    386. 

  386.         case 297: if (n[297]++ > 0) check ('a string 297'); break;
    387. 

  387.         case 298: if (n[298]++ > 0) check ('a string 298'); break;
    388. 

  388.         case 299: if (n[299]++ > 0) check ('a string 299'); break;
    389. 

  389.         case 300: if (n[300]++ > 0) check ('a string 300'); break;
    390. 

  390.         case 301: if (n[301]++ > 0) check ('a string 301'); break;
    391. 

  391.         case 302: if (n[302]++ > 0) check ('a string 302'); break;
    392. 

  392.         case 303: if (n[303]++ > 0) check ('a string 303'); break;
    393. 

  393.         case 304: if (n[304]++ > 0) check ('a string 304'); break;
    394. 

  394.         case 305: if (n[305]++ > 0) check ('a string 305'); break;
    395. 

  395.         case 306: if (n[306]++ > 0) check ('a string 306'); break;
    396. 

  396.         case 307: if (n[307]++ > 0) check ('a string 307'); break;
    397. 

  397.         case 308: if (n[308]++ > 0) check ('a string 308'); break;
    398. 

  398.         case 309: if (n[309]++ > 0) check ('a string 309'); break;
    399. 

  399.         case 310: if (n[310]++ > 0) check ('a string 310'); break;
    400. 

  400.         case 311: if (n[311]++ > 0) check ('a string 311'); break;
    401. 

  401.         case 312: if (n[312]++ > 0) check ('a string 312'); break;
    402. 

  402.         case 313: if (n[313]++ > 0) check ('a string 313'); break;
    403. 

  403.         case 314: if (n[314]++ > 0) check ('a string 314'); break;
    404. 

  404.         case 315: if (n[315]++ > 0) check ('a string 315'); break;
    405. 

  405.         case 316: if (n[316]++ > 0) check ('a string 316'); break;
    406. 

  406.         case 317: if (n[317]++ > 0) check ('a string 317'); break;
    407. 

  407.         case 318: if (n[318]++ > 0) check ('a string 318'); break;
    408. 

  408.         case 319: if (n[319]++ > 0) check ('a string 319'); break;
    409. 

  409.         case 320: if (n[320]++ > 0) check ('a string 320'); break;
    410. 

  410.         case 321: if (n[321]++ > 0) check ('a string 321'); break;
    411. 

  411.         case 322: if (n[322]++ > 0) check ('a string 322'); break;
    412. 

  412.         case 323: if (n[323]++ > 0) check ('a string 323'); break;
    413. 

  413.         case 324: if (n[324]++ > 0) check ('a string 324'); break;
    414. 

  414.         case 325: if (n[325]++ > 0) check ('a string 325'); break;
    415. 

  415.         case 326: if (n[326]++ > 0) check ('a string 326'); break;
    416. 

  416.         case 327: if (n[327]++ > 0) check ('a string 327'); break;
    417. 

  417.         case 328: if (n[328]++ > 0) check ('a string 328'); break;
    418. 

  418.         case 329: if (n[329]++ > 0) check ('a string 329'); break;
    419. 

  419.         case 330: if (n[330]++ > 0) check ('a string 330'); break;
    420. 

  420.         case 331: if (n[331]++ > 0) check ('a string 331'); break;
    421. 

  421.         case 332: if (n[332]++ > 0) check ('a string 332'); break;
    422. 

  422.         case 333: if (n[333]++ > 0) check ('a string 333'); break;
    423. 

  423.         case 334: if (n[334]++ > 0) check ('a string 334'); break;
    424. 

  424.         case 335: if (n[335]++ > 0) check ('a string 335'); break;
    425. 

  425.         case 336: if (n[336]++ > 0) check ('a string 336'); break;
    426. 

  426.         case 337: if (n[337]++ > 0) check ('a string 337'); break;
    427. 

  427.         case 338: if (n[338]++ > 0) check ('a string 338'); break;
    428. 

  428.         case 339: if (n[339]++ > 0) check ('a string 339'); break;
    429. 

  429.         case 340: if (n[340]++ > 0) check ('a string 340'); break;
    430. 

  430.         case 341: if (n[341]++ > 0) check ('a string 341'); break;
    431. 

  431.         case 342: if (n[342]++ > 0) check ('a string 342'); break;
    432. 

  432.         case 343: if (n[343]++ > 0) check ('a string 343'); break;
    433. 

  433.         case 344: if (n[344]++ > 0) check ('a string 344'); break;
    434. 

  434.         case 345: if (n[345]++ > 0) check ('a string 345'); break;
    435. 

  435.         case 346: if (n[346]++ > 0) check ('a string 346'); break;
    436. 

  436.         case 347: if (n[347]++ > 0) check ('a string 347'); break;
    437. 

  437.         case 348: if (n[348]++ > 0) check ('a string 348'); break;
    438. 

  438.         case 349: if (n[349]++ > 0) check ('a string 349'); break;
    439. 

  439.         case 350: if (n[350]++ > 0) check ('a string 350'); break;
    440. 

  440.         case 351: if (n[351]++ > 0) check ('a string 351'); break;
    441. 

  441.         case 352: if (n[352]++ > 0) check ('a string 352'); break;
    442. 

  442.         case 353: if (n[353]++ > 0) check ('a string 353'); break;
    443. 

  443.         case 354: if (n[354]++ > 0) check ('a string 354'); break;
    444. 

  444.         case 355: if (n[355]++ > 0) check ('a string 355'); break;
    445. 

  445.         case 356: if (n[356]++ > 0) check ('a string 356'); break;
    446. 

  446.         case 357: if (n[357]++ > 0) check ('a string 357'); break;
    447. 

  447.         case 358: if (n[358]++ > 0) check ('a string 358'); break;
    448. 

  448.         case 359: if (n[359]++ > 0) check ('a string 359'); break;
    449. 

  449.         case 360: if (n[360]++ > 0) check ('a string 360'); break;
    450. 

  450.         case 361: if (n[361]++ > 0) check ('a string 361'); break;
    451. 

  451.         case 362: if (n[362]++ > 0) check ('a string 362'); break;
    452. 

  452.         case 363: if (n[363]++ > 0) check ('a string 363'); break;
    453. 

  453.         case 364: if (n[364]++ > 0) check ('a string 364'); break;
    454. 

  454.         case 365: if (n[365]++ > 0) check ('a string 365'); break;
    455. 

  455.         case 366: if (n[366]++ > 0) check ('a string 366'); break;
    456. 

  456.         case 367: if (n[367]++ > 0) check ('a string 367'); break;
    457. 

  457.         case 368: if (n[368]++ > 0) check ('a string 368'); break;
    458. 

  458.         case 369: if (n[369]++ > 0) check ('a string 369'); break;
    459. 

  459.         case 370: if (n[370]++ > 0) check ('a string 370'); break;
    460. 

  460.         case 371: if (n[371]++ > 0) check ('a string 371'); break;
    461. 

  461.         case 372: if (n[372]++ > 0) check ('a string 372'); break;
    462. 

  462.         case 373: if (n[373]++ > 0) check ('a string 373'); break;
    463. 

  463.         case 374: if (n[374]++ > 0) check ('a string 374'); break;
    464. 

  464.         case 375: if (n[375]++ > 0) check ('a string 375'); break;
    465. 

  465.         case 376: if (n[376]++ > 0) check ('a string 376'); break;
    466. 

  466.         case 377: if (n[377]++ > 0) check ('a string 377'); break;
    467. 

  467.         case 378: if (n[378]++ > 0) check ('a string 378'); break;
    468. 

  468.         case 379: if (n[379]++ > 0) check ('a string 379'); break;
    469. 

  469.         case 380: if (n[380]++ > 0) check ('a string 380'); break;
    470. 

  470.         case 381: if (n[381]++ > 0) check ('a string 381'); break;
    471. 

  471.         case 382: if (n[382]++ > 0) check ('a string 382'); break;
    472. 

  472.         case 383: if (n[383]++ > 0) check ('a string 383'); break;
    473. 

  473.         case 384: if (n[384]++ > 0) check ('a string 384'); break;
    474. 

  474.         case 385: if (n[385]++ > 0) check ('a string 385'); break;
    475. 

  475.         case 386: if (n[386]++ > 0) check ('a string 386'); break;
    476. 

  476.         case 387: if (n[387]++ > 0) check ('a string 387'); break;
    477. 

  477.         case 388: if (n[388]++ > 0) check ('a string 388'); break;
    478. 

  478.         case 389: if (n[389]++ > 0) check ('a string 389'); break;
    479. 

  479.         case 390: if (n[390]++ > 0) check ('a string 390'); break;
    480. 

  480.         case 391: if (n[391]++ > 0) check ('a string 391'); break;
    481. 

  481.         case 392: if (n[392]++ > 0) check ('a string 392'); break;
    482. 

  482.         case 393: if (n[393]++ > 0) check ('a string 393'); break;
    483. 

  483.         case 394: if (n[394]++ > 0) check ('a string 394'); break;
    484. 

  484.         case 395: if (n[395]++ > 0) check ('a string 395'); break;
    485. 

  485.         case 396: if (n[396]++ > 0) check ('a string 396'); break;
    486. 

  486.         case 397: if (n[397]++ > 0) check ('a string 397'); break;
    487. 

  487.         case 398: if (n[398]++ > 0) check ('a string 398'); break;
    488. 

  488.         case 399: if (n[399]++ > 0) check ('a string 399'); break;
    489. 

  489.         case 400: if (n[400]++ > 0) check ('a string 400'); break;
    490. 

  490.         case 401: if (n[401]++ > 0) check ('a string 401'); break;
    491. 

  491.         case 402: if (n[402]++ > 0) check ('a string 402'); break;
    492. 

  492.         case 403: if (n[403]++ > 0) check ('a string 403'); break;
    493. 

  493.         case 404: if (n[404]++ > 0) check ('a string 404'); break;
    494. 

  494.         case 405: if (n[405]++ > 0) check ('a string 405'); break;
    495. 

  495.         case 406: if (n[406]++ > 0) check ('a string 406'); break;
    496. 

  496.         case 407: if (n[407]++ > 0) check ('a string 407'); break;
    497. 

  497.         case 408: if (n[408]++ > 0) check ('a string 408'); break;
    498. 

  498.         case 409: if (n[409]++ > 0) check ('a string 409'); break;
    499. 

  499.         case 410: if (n[410]++ > 0) check ('a string 410'); break;
    500. 

  500.         case 411: if (n[411]++ > 0) check ('a string 411'); break;
    501. 

  501.         case 412: if (n[412]++ > 0) check ('a string 412'); break;
    502. 

  502.         case 413: if (n[413]++ > 0) check ('a string 413'); break;
    503. 

  503.         case 414: if (n[414]++ > 0) check ('a string 414'); break;
    504. 

  504.         case 415: if (n[415]++ > 0) check ('a string 415'); break;
    505. 

  505.         case 416: if (n[416]++ > 0) check ('a string 416'); break;
    506. 

  506.         case 417: if (n[417]++ > 0) check ('a string 417'); break;
    507. 

  507.         case 418: if (n[418]++ > 0) check ('a string 418'); break;
    508. 

  508.         case 419: if (n[419]++ > 0) check ('a string 419'); break;
    509. 

  509.         case 420: if (n[420]++ > 0) check ('a string 420'); break;
    510. 

  510.         case 421: if (n[421]++ > 0) check ('a string 421'); break;
    511. 

  511.         case 422: if (n[422]++ > 0) check ('a string 422'); break;
    512. 

  512.         case 423: if (n[423]++ > 0) check ('a string 423'); break;
    513. 

  513.         case 424: if (n[424]++ > 0) check ('a string 424'); break;
    514. 

  514.         case 425: if (n[425]++ > 0) check ('a string 425'); break;
    515. 

  515.         case 426: if (n[426]++ > 0) check ('a string 426'); break;
    516. 

  516.         case 427: if (n[427]++ > 0) check ('a string 427'); break;
    517. 

  517.         case 428: if (n[428]++ > 0) check ('a string 428'); break;
    518. 

  518.         case 429: if (n[429]++ > 0) check ('a string 429'); break;
    519. 

  519.         case 430: if (n[430]++ > 0) check ('a string 430'); break;
    520. 

  520.         case 431: if (n[431]++ > 0) check ('a string 431'); break;
    521. 

  521.         case 432: if (n[432]++ > 0) check ('a string 432'); break;
    522. 

  522.         case 433: if (n[433]++ > 0) check ('a string 433'); break;
    523. 

  523.         case 434: if (n[434]++ > 0) check ('a string 434'); break;
    524. 

  524.         case 435: if (n[435]++ > 0) check ('a string 435'); break;
    525. 

  525.         case 436: if (n[436]++ > 0) check ('a string 436'); break;
    526. 

  526.         case 437: if (n[437]++ > 0) check ('a string 437'); break;
    527. 

  527.         case 438: if (n[438]++ > 0) check ('a string 438'); break;
    528. 

  528.         case 439: if (n[439]++ > 0) check ('a string 439'); break;
    529. 

  529.         case 440: if (n[440]++ > 0) check ('a string 440'); break;
    530. 

  530.         case 441: if (n[441]++ > 0) check ('a string 441'); break;
    531. 

  531.         case 442: if (n[442]++ > 0) check ('a string 442'); break;
    532. 

  532.         case 443: if (n[443]++ > 0) check ('a string 443'); break;
    533. 

  533.         case 444: if (n[444]++ > 0) check ('a string 444'); break;
    534. 

  534.         case 445: if (n[445]++ > 0) check ('a string 445'); break;
    535. 

  535.         case 446: if (n[446]++ > 0) check ('a string 446'); break;
    536. 

  536.         case 447: if (n[447]++ > 0) check ('a string 447'); break;
    537. 

  537.         case 448: if (n[448]++ > 0) check ('a string 448'); break;
    538. 

  538.         case 449: if (n[449]++ > 0) check ('a string 449'); break;
    539. 

  539.         case 450: if (n[450]++ > 0) check ('a string 450'); break;
    540. 

  540.         case 451: if (n[451]++ > 0) check ('a string 451'); break;
    541. 

  541.         case 452: if (n[452]++ > 0) check ('a string 452'); break;
    542. 

  542.         case 453: if (n[453]++ > 0) check ('a string 453'); break;
    543. 

  543.         case 454: if (n[454]++ > 0) check ('a string 454'); break;
    544. 

  544.         case 455: if (n[455]++ > 0) check ('a string 455'); break;
    545. 

  545.         case 456: if (n[456]++ > 0) check ('a string 456'); break;
    546. 

  546.         case 457: if (n[457]++ > 0) check ('a string 457'); break;
    547. 

  547.         case 458: if (n[458]++ > 0) check ('a string 458'); break;
    548. 

  548.         case 459: if (n[459]++ > 0) check ('a string 459'); break;
    549. 

  549.         case 460: if (n[460]++ > 0) check ('a string 460'); break;
    550. 

  550.         case 461: if (n[461]++ > 0) check ('a string 461'); break;
    551. 

  551.         case 462: if (n[462]++ > 0) check ('a string 462'); break;
    552. 

  552.         case 463: if (n[463]++ > 0) check ('a string 463'); break;
    553. 

  553.         case 464: if (n[464]++ > 0) check ('a string 464'); break;
    554. 

  554.         case 465: if (n[465]++ > 0) check ('a string 465'); break;
    555. 

  555.         case 466: if (n[466]++ > 0) check ('a string 466'); break;
    556. 

  556.         case 467: if (n[467]++ > 0) check ('a string 467'); break;
    557. 

  557.         case 468: if (n[468]++ > 0) check ('a string 468'); break;
    558. 

  558.         case 469: if (n[469]++ > 0) check ('a string 469'); break;
    559. 

  559.         case 470: if (n[470]++ > 0) check ('a string 470'); break;
    560. 

  560.         case 471: if (n[471]++ > 0) check ('a string 471'); break;
    561. 

  561.         case 472: if (n[472]++ > 0) check ('a string 472'); break;
    562. 

  562.         case 473: if (n[473]++ > 0) check ('a string 473'); break;
    563. 

  563.         case 474: if (n[474]++ > 0) check ('a string 474'); break;
    564. 

  564.         case 475: if (n[475]++ > 0) check ('a string 475'); break;
    565. 

  565.         case 476: if (n[476]++ > 0) check ('a string 476'); break;
    566. 

  566.         case 477: if (n[477]++ > 0) check ('a string 477'); break;
    567. 

  567.         case 478: if (n[478]++ > 0) check ('a string 478'); break;
    568. 

  568.         case 479: if (n[479]++ > 0) check ('a string 479'); break;
    569. 

  569.         case 480: if (n[480]++ > 0) check ('a string 480'); break;
    570. 

  570.         case 481: if (n[481]++ > 0) check ('a string 481'); break;
    571. 

  571.         case 482: if (n[482]++ > 0) check ('a string 482'); break;
    572. 

  572.         case 483: if (n[483]++ > 0) check ('a string 483'); break;
    573. 

  573.         case 484: if (n[484]++ > 0) check ('a string 484'); break;
    574. 

  574.         case 485: if (n[485]++ > 0) check ('a string 485'); break;
    575. 

  575.         case 486: if (n[486]++ > 0) check ('a string 486'); break;
    576. 

  576.         case 487: if (n[487]++ > 0) check ('a string 487'); break;
    577. 

  577.         case 488: if (n[488]++ > 0) check ('a string 488'); break;
    578. 

  578.         case 489: if (n[489]++ > 0) check ('a string 489'); break;
    579. 

  579.         case 490: if (n[490]++ > 0) check ('a string 490'); break;
    580. 

  580.         case 491: if (n[491]++ > 0) check ('a string 491'); break;
    581. 

  581.         case 492: if (n[492]++ > 0) check ('a string 492'); break;
    582. 

  582.         case 493: if (n[493]++ > 0) check ('a string 493'); break;
    583. 

  583.         case 494: if (n[494]++ > 0) check ('a string 494'); break;
    584. 

  584.         case 495: if (n[495]++ > 0) check ('a string 495'); break;
    585. 

  585.         case 496: if (n[496]++ > 0) check ('a string 496'); break;
    586. 

  586.         case 497: if (n[497]++ > 0) check ('a string 497'); break;
    587. 

  587.         case 498: if (n[498]++ > 0) check ('a string 498'); break;
    588. 

  588.         case 499: if (n[499]++ > 0) check ('a string 499'); break;
    589. 

  589.         case 500: if (n[500]++ > 0) check ('a string 500'); break;
    590. 

  590.         case 501: if (n[501]++ > 0) check ('a string 501'); break;
    591. 

  591.         case 502: if (n[502]++ > 0) check ('a string 502'); break;
    592. 

  592.         case 503: if (n[503]++ > 0) check ('a string 503'); break;
    593. 

  593.         case 504: if (n[504]++ > 0) check ('a string 504'); break;
    594. 

  594.         case 505: if (n[505]++ > 0) check ('a string 505'); break;
    595. 

  595.         case 506: if (n[506]++ > 0) check ('a string 506'); break;
    596. 

  596.         case 507: if (n[507]++ > 0) check ('a string 507'); break;
    597. 

  597.         case 508: if (n[508]++ > 0) check ('a string 508'); break;
    598. 

  598.         case 509: if (n[509]++ > 0) check ('a string 509'); break;
    599. 

  599.         case 510: if (n[510]++ > 0) check ('a string 510'); break;
    600. 

  600.         case 511: if (n[511]++ > 0) check ('a string 511'); break;
    601. 

  601.         case 512: if (n[512]++ > 0) check ('a string 512'); break;
    602. 

  602.         case 513: if (n[513]++ > 0) check ('a string 513'); break;
    603. 

  603.         case 514: if (n[514]++ > 0) check ('a string 514'); break;
    604. 

  604.         case 515: if (n[515]++ > 0) check ('a string 515'); break;
    605. 

  605.         case 516: if (n[516]++ > 0) check ('a string 516'); break;
    606. 

  606.         case 517: if (n[517]++ > 0) check ('a string 517'); break;
    607. 

  607.         case 518: if (n[518]++ > 0) check ('a string 518'); break;
    608. 

  608.         case 519: if (n[519]++ > 0) check ('a string 519'); break;
    609. 

  609.         case 520: if (n[520]++ > 0) check ('a string 520'); break;
    610. 

  610.         case 521: if (n[521]++ > 0) check ('a string 521'); break;
    611. 

  611.         case 522: if (n[522]++ > 0) check ('a string 522'); break;
    612. 

  612.         case 523: if (n[523]++ > 0) check ('a string 523'); break;
    613. 

  613.         case 524: if (n[524]++ > 0) check ('a string 524'); break;
    614. 

  614.         case 525: if (n[525]++ > 0) check ('a string 525'); break;
    615. 

  615.         case 526: if (n[526]++ > 0) check ('a string 526'); break;
    616. 

  616.         case 527: if (n[527]++ > 0) check ('a string 527'); break;
    617. 

  617.         case 528: if (n[528]++ > 0) check ('a string 528'); break;
    618. 

  618.         case 529: if (n[529]++ > 0) check ('a string 529'); break;
    619. 

  619.         case 530: if (n[530]++ > 0) check ('a string 530'); break;
    620. 

  620.         case 531: if (n[531]++ > 0) check ('a string 531'); break;
    621. 

  621.         case 532: if (n[532]++ > 0) check ('a string 532'); break;
    622. 

  622.         case 533: if (n[533]++ > 0) check ('a string 533'); break;
    623. 

  623.         case 534: if (n[534]++ > 0) check ('a string 534'); break;
    624. 

  624.         case 535: if (n[535]++ > 0) check ('a string 535'); break;
    625. 

  625.         case 536: if (n[536]++ > 0) check ('a string 536'); break;
    626. 

  626.         case 537: if (n[537]++ > 0) check ('a string 537'); break;
    627. 

  627.         case 538: if (n[538]++ > 0) check ('a string 538'); break;
    628. 

  628.         case 539: if (n[539]++ > 0) check ('a string 539'); break;
    629. 

  629.         case 540: if (n[540]++ > 0) check ('a string 540'); break;
    630. 

  630.         case 541: if (n[541]++ > 0) check ('a string 541'); break;
    631. 

  631.         case 542: if (n[542]++ > 0) check ('a string 542'); break;
    632. 

  632.         case 543: if (n[543]++ > 0) check ('a string 543'); break;
    633. 

  633.         case 544: if (n[544]++ > 0) check ('a string 544'); break;
    634. 

  634.         case 545: if (n[545]++ > 0) check ('a string 545'); break;
    635. 

  635.         case 546: if (n[546]++ > 0) check ('a string 546'); break;
    636. 

  636.         case 547: if (n[547]++ > 0) check ('a string 547'); break;
    637. 

  637.         case 548: if (n[548]++ > 0) check ('a string 548'); break;
    638. 

  638.         case 549: if (n[549]++ > 0) check ('a string 549'); break;
    639. 

  639.         case 550: if (n[550]++ > 0) check ('a string 550'); break;
    640. 

  640.         case 551: if (n[551]++ > 0) check ('a string 551'); break;
    641. 

  641.         case 552: if (n[552]++ > 0) check ('a string 552'); break;
    642. 

  642.         case 553: if (n[553]++ > 0) check ('a string 553'); break;
    643. 

  643.         case 554: if (n[554]++ > 0) check ('a string 554'); break;
    644. 

  644.         case 555: if (n[555]++ > 0) check ('a string 555'); break;
    645. 

  645.         case 556: if (n[556]++ > 0) check ('a string 556'); break;
    646. 

  646.         case 557: if (n[557]++ > 0) check ('a string 557'); break;
    647. 

  647.         case 558: if (n[558]++ > 0) check ('a string 558'); break;
    648. 

  648.         case 559: if (n[559]++ > 0) check ('a string 559'); break;
    649. 

  649.         case 560: if (n[560]++ > 0) check ('a string 560'); break;
    650. 

  650.         case 561: if (n[561]++ > 0) check ('a string 561'); break;
    651. 

  651.         case 562: if (n[562]++ > 0) check ('a string 562'); break;
    652. 

  652.         case 563: if (n[563]++ > 0) check ('a string 563'); break;
    653. 

  653.         case 564: if (n[564]++ > 0) check ('a string 564'); break;
    654. 

  654.         case 565: if (n[565]++ > 0) check ('a string 565'); break;
    655. 

  655.         case 566: if (n[566]++ > 0) check ('a string 566'); break;
    656. 

  656.         case 567: if (n[567]++ > 0) check ('a string 567'); break;
    657. 

  657.         case 568: if (n[568]++ > 0) check ('a string 568'); break;
    658. 

  658.         case 569: if (n[569]++ > 0) check ('a string 569'); break;
    659. 

  659.         case 570: if (n[570]++ > 0) check ('a string 570'); break;
    660. 

  660.         case 571: if (n[571]++ > 0) check ('a string 571'); break;
    661. 

  661.         case 572: if (n[572]++ > 0) check ('a string 572'); break;
    662. 

  662.         case 573: if (n[573]++ > 0) check ('a string 573'); break;
    663. 

  663.         case 574: if (n[574]++ > 0) check ('a string 574'); break;
    664. 

  664.         case 575: if (n[575]++ > 0) check ('a string 575'); break;
    665. 

  665.         case 576: if (n[576]++ > 0) check ('a string 576'); break;
    666. 

  666.         case 577: if (n[577]++ > 0) check ('a string 577'); break;
    667. 

  667.         case 578: if (n[578]++ > 0) check ('a string 578'); break;
    668. 

  668.         case 579: if (n[579]++ > 0) check ('a string 579'); break;
    669. 

  669.         case 580: if (n[580]++ > 0) check ('a string 580'); break;
    670. 

  670.         case 581: if (n[581]++ > 0) check ('a string 581'); break;
    671. 

  671.         case 582: if (n[582]++ > 0) check ('a string 582'); break;
    672. 

  672.         case 583: if (n[583]++ > 0) check ('a string 583'); break;
    673. 

  673.         case 584: if (n[584]++ > 0) check ('a string 584'); break;
    674. 

  674.         case 585: if (n[585]++ > 0) check ('a string 585'); break;
    675. 

  675.         case 586: if (n[586]++ > 0) check ('a string 586'); break;
    676. 

  676.         case 587: if (n[587]++ > 0) check ('a string 587'); break;
    677. 

  677.         case 588: if (n[588]++ > 0) check ('a string 588'); break;
    678. 

  678.         case 589: if (n[589]++ > 0) check ('a string 589'); break;
    679. 

  679.         case 590: if (n[590]++ > 0) check ('a string 590'); break;
    680. 

  680.         case 591: if (n[591]++ > 0) check ('a string 591'); break;
    681. 

  681.         case 592: if (n[592]++ > 0) check ('a string 592'); break;
    682. 

  682.         case 593: if (n[593]++ > 0) check ('a string 593'); break;
    683. 

  683.         case 594: if (n[594]++ > 0) check ('a string 594'); break;
    684. 

  684.         case 595: if (n[595]++ > 0) check ('a string 595'); break;
    685. 

  685.         case 596: if (n[596]++ > 0) check ('a string 596'); break;
    686. 

  686.         case 597: if (n[597]++ > 0) check ('a string 597'); break;
    687. 

  687.         case 598: if (n[598]++ > 0) check ('a string 598'); break;
    688. 

  688.         case 599: if (n[599]++ > 0) check ('a string 599'); break;
    689. 

  689.         case 600: if (n[600]++ > 0) check ('a string 600'); break;
    690. 

  690.         case 601: if (n[601]++ > 0) check ('a string 601'); break;
    691. 

  691.         case 602: if (n[602]++ > 0) check ('a string 602'); break;
    692. 

  692.         case 603: if (n[603]++ > 0) check ('a string 603'); break;
    693. 

  693.         case 604: if (n[604]++ > 0) check ('a string 604'); break;
    694. 

  694.         case 605: if (n[605]++ > 0) check ('a string 605'); break;
    695. 

  695.         case 606: if (n[606]++ > 0) check ('a string 606'); break;
    696. 

  696.         case 607: if (n[607]++ > 0) check ('a string 607'); break;
    697. 

  697.         case 608: if (n[608]++ > 0) check ('a string 608'); break;
    698. 

  698.         case 609: if (n[609]++ > 0) check ('a string 609'); break;
    699. 

  699.         case 610: if (n[610]++ > 0) check ('a string 610'); break;
    700. 

  700.         case 611: if (n[611]++ > 0) check ('a string 611'); break;
    701. 

  701.         case 612: if (n[612]++ > 0) check ('a string 612'); break;
    702. 

  702.         case 613: if (n[613]++ > 0) check ('a string 613'); break;
    703. 

  703.         case 614: if (n[614]++ > 0) check ('a string 614'); break;
    704. 

  704.         case 615: if (n[615]++ > 0) check ('a string 615'); break;
    705. 

  705.         case 616: if (n[616]++ > 0) check ('a string 616'); break;
    706. 

  706.         case 617: if (n[617]++ > 0) check ('a string 617'); break;
    707. 

  707.         case 618: if (n[618]++ > 0) check ('a string 618'); break;
    708. 

  708.         case 619: if (n[619]++ > 0) check ('a string 619'); break;
    709. 

  709.         case 620: if (n[620]++ > 0) check ('a string 620'); break;
    710. 

  710.         case 621: if (n[621]++ > 0) check ('a string 621'); break;
    711. 

  711.         case 622: if (n[622]++ > 0) check ('a string 622'); break;
    712. 

  712.         case 623: if (n[623]++ > 0) check ('a string 623'); break;
    713. 

  713.         case 624: if (n[624]++ > 0) check ('a string 624'); break;
    714. 

  714.         case 625: if (n[625]++ > 0) check ('a string 625'); break;
    715. 

  715.         case 626: if (n[626]++ > 0) check ('a string 626'); break;
    716. 

  716.         case 627: if (n[627]++ > 0) check ('a string 627'); break;
    717. 

  717.         case 628: if (n[628]++ > 0) check ('a string 628'); break;
    718. 

  718.         case 629: if (n[629]++ > 0) check ('a string 629'); break;
    719. 

  719.         case 630: if (n[630]++ > 0) check ('a string 630'); break;
    720. 

  720.         case 631: if (n[631]++ > 0) check ('a string 631'); break;
    721. 

  721.         case 632: if (n[632]++ > 0) check ('a string 632'); break;
    722. 

  722.         case 633: if (n[633]++ > 0) check ('a string 633'); break;
    723. 

  723.         case 634: if (n[634]++ > 0) check ('a string 634'); break;
    724. 

  724.         case 635: if (n[635]++ > 0) check ('a string 635'); break;
    725. 

  725.         case 636: if (n[636]++ > 0) check ('a string 636'); break;
    726. 

  726.         case 637: if (n[637]++ > 0) check ('a string 637'); break;
    727. 

  727.         case 638: if (n[638]++ > 0) check ('a string 638'); break;
    728. 

  728.         case 639: if (n[639]++ > 0) check ('a string 639'); break;
    729. 

  729.         case 640: if (n[640]++ > 0) check ('a string 640'); break;
    730. 

  730.         case 641: if (n[641]++ > 0) check ('a string 641'); break;
    731. 

  731.         case 642: if (n[642]++ > 0) check ('a string 642'); break;
    732. 

  732.         case 643: if (n[643]++ > 0) check ('a string 643'); break;
    733. 

  733.         case 644: if (n[644]++ > 0) check ('a string 644'); break;
    734. 

  734.         case 645: if (n[645]++ > 0) check ('a string 645'); break;
    735. 

  735.         case 646: if (n[646]++ > 0) check ('a string 646'); break;
    736. 

  736.         case 647: if (n[647]++ > 0) check ('a string 647'); break;
    737. 

  737.         case 648: if (n[648]++ > 0) check ('a string 648'); break;
    738. 

  738.         case 649: if (n[649]++ > 0) check ('a string 649'); break;
    739. 

  739.         case 650: if (n[650]++ > 0) check ('a string 650'); break;
    740. 

  740.         case 651: if (n[651]++ > 0) check ('a string 651'); break;
    741. 

  741.         case 652: if (n[652]++ > 0) check ('a string 652'); break;
    742. 

  742.         case 653: if (n[653]++ > 0) check ('a string 653'); break;
    743. 

  743.         case 654: if (n[654]++ > 0) check ('a string 654'); break;
    744. 

  744.         case 655: if (n[655]++ > 0) check ('a string 655'); break;
    745. 

  745.         case 656: if (n[656]++ > 0) check ('a string 656'); break;
    746. 

  746.         case 657: if (n[657]++ > 0) check ('a string 657'); break;
    747. 

  747.         case 658: if (n[658]++ > 0) check ('a string 658'); break;
    748. 

  748.         case 659: if (n[659]++ > 0) check ('a string 659'); break;
    749. 

  749.         case 660: if (n[660]++ > 0) check ('a string 660'); break;
    750. 

  750.         case 661: if (n[661]++ > 0) check ('a string 661'); break;
    751. 

  751.         case 662: if (n[662]++ > 0) check ('a string 662'); break;
    752. 

  752.         case 663: if (n[663]++ > 0) check ('a string 663'); break;
    753. 

  753.         case 664: if (n[664]++ > 0) check ('a string 664'); break;
    754. 

  754.         case 665: if (n[665]++ > 0) check ('a string 665'); break;
    755. 

  755.         case 666: if (n[666]++ > 0) check ('a string 666'); break;
    756. 

  756.         case 667: if (n[667]++ > 0) check ('a string 667'); break;
    757. 

  757.         case 668: if (n[668]++ > 0) check ('a string 668'); break;
    758. 

  758.         case 669: if (n[669]++ > 0) check ('a string 669'); break;
    759. 

  759.         case 670: if (n[670]++ > 0) check ('a string 670'); break;
    760. 

  760.         case 671: if (n[671]++ > 0) check ('a string 671'); break;
    761. 

  761.         case 672: if (n[672]++ > 0) check ('a string 672'); break;
    762. 

  762.         case 673: if (n[673]++ > 0) check ('a string 673'); break;
    763. 

  763.         case 674: if (n[674]++ > 0) check ('a string 674'); break;
    764. 

  764.         case 675: if (n[675]++ > 0) check ('a string 675'); break;
    765. 

  765.         case 676: if (n[676]++ > 0) check ('a string 676'); break;
    766. 

  766.         case 677: if (n[677]++ > 0) check ('a string 677'); break;
    767. 

  767.         case 678: if (n[678]++ > 0) check ('a string 678'); break;
    768. 

  768.         case 679: if (n[679]++ > 0) check ('a string 679'); break;
    769. 

  769.         case 680: if (n[680]++ > 0) check ('a string 680'); break;
    770. 

  770.         case 681: if (n[681]++ > 0) check ('a string 681'); break;
    771. 

  771.         case 682: if (n[682]++ > 0) check ('a string 682'); break;
    772. 

  772.         case 683: if (n[683]++ > 0) check ('a string 683'); break;
    773. 

  773.         case 684: if (n[684]++ > 0) check ('a string 684'); break;
    774. 

  774.         case 685: if (n[685]++ > 0) check ('a string 685'); break;
    775. 

  775.         case 686: if (n[686]++ > 0) check ('a string 686'); break;
    776. 

  776.         case 687: if (n[687]++ > 0) check ('a string 687'); break;
    777. 

  777.         case 688: if (n[688]++ > 0) check ('a string 688'); break;
    778. 

  778.         case 689: if (n[689]++ > 0) check ('a string 689'); break;
    779. 

  779.         case 690: if (n[690]++ > 0) check ('a string 690'); break;
    780. 

  780.         case 691: if (n[691]++ > 0) check ('a string 691'); break;
    781. 

  781.         case 692: if (n[692]++ > 0) check ('a string 692'); break;
    782. 

  782.         case 693: if (n[693]++ > 0) check ('a string 693'); break;
    783. 

  783.         case 694: if (n[694]++ > 0) check ('a string 694'); break;
    784. 

  784.         case 695: if (n[695]++ > 0) check ('a string 695'); break;
    785. 

  785.         case 696: if (n[696]++ > 0) check ('a string 696'); break;
    786. 

  786.         case 697: if (n[697]++ > 0) check ('a string 697'); break;
    787. 

  787.         case 698: if (n[698]++ > 0) check ('a string 698'); break;
    788. 

  788.         case 699: if (n[699]++ > 0) check ('a string 699'); break;
    789. 

  789.         case 700: if (n[700]++ > 0) check ('a string 700'); break;
    790. 

  790.         case 701: if (n[701]++ > 0) check ('a string 701'); break;
    791. 

  791.         case 702: if (n[702]++ > 0) check ('a string 702'); break;
    792. 

  792.         case 703: if (n[703]++ > 0) check ('a string 703')…
    793.

Large files files are truncated, but you can click here to view the full file