PageRenderTime 41ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/AKDOA28/ZX.EHR.ResumeParseLib/Encoding/IdentifyEncoding.cs

#
C# | 2523 lines | 2171 code | 142 blank | 210 comment | 232 complexity | 86147ac96d7c57498271e0c74a920e7b MD5 | raw file
Possible License(s): LGPL-2.1, LGPL-3.0, Apache-2.0, GPL-2.0, BSD-3-Clause, LGPL-2.0, MIT, GPL-3.0 
    

  1. using System;

    2. 

  2. using System.Collections.Generic;

    3. 

  3. using System.Linq;

    4. 

  4. using System.Text;

    5. 

  5. 

    6. 

  6. namespace ZX.EHR.ResumeParseLib

    7. 

  7. {

    8. 

  8.     #region 文件编码识别类.

    9. 

  9. 

    10. 

  10.     /// <summary>

    11. 

  11.     /// 检测字符编码的类

    12. 

  12.     /// <seealso cref="System.IO.Stream"/>

    13. 

  13.     /// <seealso cref="System.Uri"/>

    14. 

  14.     /// <seealso cref="System.IO.FileInfo"/>

    15. 

  15.     /// </summary>

    16. 

  16.     /// <remarks>

    17. 

  17.     /// <![CDATA[

    18. 

  18.     /// <strong>IdentifyEncoding</strong> 用来检测 <see cref="Uri"/>,<see cref="System.IO.FileInfo"/>,<see cref="sbyte"/> 字节数组的编码．

    19. 

  19.     /// Create By lion  <br/>

    20. 

  20.     /// 2005-02-21 22:00  <br/>

    21. 

  21.     /// Support .Net Framework v1.1.4322 <br/> 

    22. 

  22.     /// WebSite：www.lionsky.net(lion-a AT sohu.com) <br/> 

    23. 

  23.     /// ]]>

    24. 

  24.     /// </remarks>

    25. 

  25.     public class IdentifyEncoding

    26. 

  26.     {

    27. 

  27.         #region Fields.....

    28. 

  28. 

    29. 

  29.         // Frequency tables to hold the GB, Big5, and EUC-TW character

    30. 

  30.         // frequencies

    31. 

  31.         internal static int[][] GBFreq = new int[94][];

    32. 

  32.         internal static int[][] GBKFreq = new int[126][];

    33. 

  33.         internal static int[][] Big5Freq = new int[94][];

    34. 

  34.         internal static int[][] EUC_TWFreq = new int[94][];

    35. 

  35. 

    36. 

  36.         internal static string[] nicename = new string[]

    37. 

  37.    {

    38. 

  38.     "GB2312", "GBK", "HZ", "Big5", "CNS 11643"

    39. 

  39.     , "ISO 2022CN", "UTF-8", "Unicode", "ASCII", "OTHER"

    40. 

  40.    };

    41. 

  41. 

    42. 

  42.         #endregion

    43. 

  43. 

    44. 

  44.         #region Methods.....

    45. 

  45. 

    46. 

  46.         /// <summary>

    47. 

  47.         /// 初始化 <see cref="IdentifyEncoding"/> 的实例

    48. 

  48.         /// </summary>

    49. 

  49.         public IdentifyEncoding()

    50. 

  50.         {

    51. 

  51.             Initialize_Frequencies();

    52. 

  52.         }

    53. 

  53. 

    54. 

  54.         #region GetEncodingName.....

    55. 

  55. 

    56. 

  56.         /// <summary>

    57. 

  57.         /// 从指定的 <see cref="Uri"/> 中判断编码类型

    58. 

  58.         /// </summary>

    59. 

  59.         /// <param name="testurl">要判断的 <see cref="Uri"/> </param>

    60. 

  60.         /// <returns>返回编码类型("GB2312", "GBK", "HZ", "Big5", "CNS 11643", "ISO 2022CN", "UTF-8", "Unicode", "ASCII", "OTHER")</returns>

    61. 

  61.         /// <example>

    62. 

  62.         /// 以下示例演示了如何调用 <see cref="GetEncodingName"/> 方法：

    63. 

  63.         /// <code>

    64. 

  64.         ///  IdentifyEncoding ide = new IdentifyEncoding();

    65. 

  65.         ///  Response.Write(ide.GetEncodingName(new Uri("http://china5.nikkeibp.co.jp/china/news/com/200307/pr_com200307170131.html")));  

    66. 

  66.         /// </code>

    67. 

  67.         /// </example>

    68. 

  68.         public virtual string GetEncodingName(System.Uri testurl)

    69. 

  69.         {

    70. 

  70.             sbyte[] rawtext = new sbyte[1024];

    71. 

  71.             int bytesread = 0, byteoffset = 0;

    72. 

  72.             System.IO.Stream chinesestream;

    73. 

  73.             try

    74. 

  74.             {

    75. 

  75.                 chinesestream = System.Net.WebRequest.Create(testurl.AbsoluteUri).GetResponse().GetResponseStream();

    76. 

  76.                 while ((bytesread = ReadInput(chinesestream, ref rawtext, byteoffset, rawtext.Length - byteoffset)) > 0)

    77. 

  77.                 {

    78. 

  78.                     byteoffset += bytesread;

    79. 

  79.                 }

    80. 

  80.                 chinesestream.Close();

    81. 

  81.             }

    82. 

  82.             catch (System.Exception e)

    83. 

  83.             {

    84. 

  84.                 System.Console.Error.WriteLine("Error loading or using URL " + e.ToString());

    85. 

  85.             }

    86. 

  86.             return GetEncodingName(rawtext);

    87. 

  87.         }

    88. 

  88. 

    89. 

  89.         /// <summary>

    90. 

  90.         /// 从指定的 <see cref="System.IO.FileInfo"/> 中判断编码类型

    91. 

  91.         /// </summary>

    92. 

  92.         /// <param name="testfile">要判断的 <see cref="System.IO.FileInfo"/> </param>

    93. 

  93.         /// <returns>返回编码类型("GB2312", "GBK", "HZ", "Big5", "CNS 11643", "ISO 2022CN", "UTF-8", "Unicode", "ASCII", "OTHER")</returns>

    94. 

  94.         /// <example>

    95. 

  95.         /// 以下示例演示了如何调用 <see cref="GetEncodingName"/> 方法：

    96. 

  96.         /// <code>

    97. 

  97.         ///  IdentifyEncoding ide = new IdentifyEncoding();

    98. 

  98.         ///  Response.Write(ide.GetEncodingName(new System.IO.FileInfo(@"C:\test.txt")));  

    99. 

  99.         /// </code>

    100. 

  100.         /// </example>

    101. 

  101.         public virtual string GetEncodingName(System.IO.FileInfo testfile)

    102. 

  102.         {

    103. 

  103.             System.IO.FileStream chinesefile;

    104. 

  104.             sbyte[] rawtext;

    105. 

  105.             rawtext = new sbyte[(int)FileLength(testfile)];

    106. 

  106.             try

    107. 

  107.             {

    108. 

  108.                 chinesefile = new System.IO.FileStream(testfile.FullName, System.IO.FileMode.Open, System.IO.FileAccess.Read);

    109. 

  109.                 ReadInput(chinesefile, ref rawtext, 0, rawtext.Length);

    110. 

  110.             }

    111. 

  111.             catch (System.Exception e)

    112. 

  112.             {

    113. 

  113.                 System.Console.Error.WriteLine("Error: " + e);

    114. 

  114.             }

    115. 

  115. 

    116. 

  116.             return GetEncodingName(rawtext);

    117. 

  117.         }

    118. 

  118. 

    119. 

  119.         public virtual Encoding GetEncoding(string encodingName)

    120. 

  120.         {

    121. 

  121.             Encoding _encode = Encoding.Default;

    122. 

  122.             if (encodingName.Length == 0)

    123. 

  123.                 return _encode;

    124. 

  124.             switch (encodingName)

    125. 

  125.             {

    126. 

  126.                 case "UTF-8":

    127. 

  127.                     _encode = Encoding.UTF8;

    128. 

  128.                     break;

    129. 

  129.                 case "Unicode":

    130. 

  130.                     _encode = Encoding.Unicode;

    131. 

  131.                     break;

    132. 

  132.             }

    133. 

  133.             return _encode;

    134. 

  134.         }

    135. 

  135. 

    136. 

  136. 

    137. 

  137.         /// <summary>

    138. 

  138.         /// 从指定的 <see cref="sbyte"/> 字节数组中判断编码类型

    139. 

  139.         /// </summary>

    140. 

  140.         /// <param name="rawtext">要判断的 <see cref="System.IO.FileInfo"/> </param>

    141. 

  141.         /// <returns>返回编码类型("GB2312", "GBK", "HZ", "Big5", "CNS 11643", "ISO 2022CN", "UTF-8", "Unicode", "ASCII", "OTHER")</returns>

    142. 

  142.         /// <example>

    143. 

  143.         /// 以下示例演示了如何调用 <see cref="GetEncodingName"/> 方法：

    144. 

  144.         /// <code>

    145. 

  145.         ///  IdentifyEncoding ide = new IdentifyEncoding();

    146. 

  146.         ///  Response.Write(ide.GetEncodingName(IdentifyEncoding.ToSByteArray(System.Text.Encoding.GetEncoding("gb2312").GetBytes("Lion互动网络(www.lionsky.net)")))); 

    147. 

  147.         /// </code>

    148. 

  148.         /// </example>

    149. 

  149.         public virtual string GetEncodingName(sbyte[] rawtext)

    150. 

  150.         {

    151. 

  151.             int[] scores;

    152. 

  152.             int index, maxscore = 0;

    153. 

  153.             int encoding_guess = 0;

    154. 

  154. 

    155. 

  155.             scores = new int[10];

    156. 

  156.             //分析编码的概率

    157. 

  157.             scores[0] = GB2312Probability(rawtext);

    158. 

  158.             scores[1] = GBKProbability(rawtext);

    159. 

  159.             scores[2] = HZProbability(rawtext);

    160. 

  160.             scores[3] = BIG5Probability(rawtext);

    161. 

  161.             scores[4] = ENCTWProbability(rawtext);

    162. 

  162.             scores[5] = ISO2022CNProbability(rawtext);

    163. 

  163.             scores[6] = UTF8Probability(rawtext);

    164. 

  164.             scores[7] = UnicodeProbability(rawtext);

    165. 

  165.             scores[8] = ASCIIProbability(rawtext);

    166. 

  166.             scores[9] = 0;

    167. 

  167. 

    168. 

  168.             // Tabulate Scores

    169. 

  169.             for (index = 0; index < 10; index++)

    170. 

  170.             {

    171. 

  171.                 if (scores[index] > maxscore)

    172. 

  172.                 {

    173. 

  173.                     encoding_guess = index;

    174. 

  174.                     maxscore = scores[index];

    175. 

  175.                 }

    176. 

  176.             }

    177. 

  177. 

    178. 

  178.             // Return OTHER if nothing scored above 50

    179. 

  179.             if (maxscore <= 50)

    180. 

  180.             {

    181. 

  181.                 encoding_guess = 9;

    182. 

  182.             }

    183. 

  183. 

    184. 

  184.             return nicename[encoding_guess];

    185. 

  185.         }

    186. 

  186. 

    187. 

  187.         #endregion

    188. 

  188. 

    189. 

  189.         #region About Probability.....

    190. 

  190. 

    191. 

  191.         #region GB2312Probability

    192. 

  192. 

    193. 

  193.         /// <summary>

    194. 

  194.         /// 判断是GB2312编码的可能性

    195. 

  195.         /// </summary>

    196. 

  196.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    197. 

  197.         /// <returns>返回 0 至 100 之间的可能性</returns>

    198. 

  198.         internal virtual int GB2312Probability(sbyte[] rawtext)

    199. 

  199.         {

    200. 

  200.             int i, rawtextlen = 0;

    201. 

  201. 

    202. 

  202.             int dbchars = 1, gbchars = 1;

    203. 

  203.             long gbfreq = 0, totalfreq = 1;

    204. 

  204.             float rangeval = 0, freqval = 0;

    205. 

  205.             int row, column;

    206. 

  206. 

    207. 

  207.             // Stage 1:  Check to see if characters fit into acceptable ranges

    208. 

  208. 

    209. 

  209.             rawtextlen = rawtext.Length;

    210. 

  210.             for (i = 0; i < rawtextlen - 1; i++)

    211. 

  211.             {

    212. 

  212.                 if (rawtext[i] >= 0)

    213. 

  213.                 {

    214. 

  214.                     //asciichars++;

    215. 

  215.                 }

    216. 

  216.                 else

    217. 

  217.                 {

    218. 

  218.                     dbchars++;

    219. 

  219.                     if ((sbyte)Identity(0xA1) <= rawtext[i] && rawtext[i] <= (sbyte)Identity(0xF7) && (sbyte)Identity(0xA1) <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)Identity(0xFE))

    220. 

  220.                     {

    221. 

  221.                         gbchars++;

    222. 

  222.                         totalfreq += 500;

    223. 

  223.                         row = rawtext[i] + 256 - 0xA1;

    224. 

  224.                         column = rawtext[i + 1] + 256 - 0xA1;

    225. 

  225.                         if (GBFreq[row][column] != 0)

    226. 

  226.                         {

    227. 

  227.                             gbfreq += GBFreq[row][column];

    228. 

  228.                         }

    229. 

  229.                         else if (15 <= row && row < 55)

    230. 

  230.                         {

    231. 

  231.                             gbfreq += 200;

    232. 

  232.                         }

    233. 

  233.                     }

    234. 

  234.                     i++;

    235. 

  235.                 }

    236. 

  236.             }

    237. 

  237. 

    238. 

  238.             rangeval = 50 * ((float)gbchars / (float)dbchars);

    239. 

  239.             freqval = 50 * ((float)gbfreq / (float)totalfreq);

    240. 

  240. 

    241. 

  241. 

    242. 

  242.             return (int)(rangeval + freqval);

    243. 

  243.         }

    244. 

  244. 

    245. 

  245.         #endregion

    246. 

  246. 

    247. 

  247.         #region GBKProbability.....

    248. 

  248. 

    249. 

  249.         /// <summary>

    250. 

  250.         /// 判断是GBK编码的可能性

    251. 

  251.         /// </summary>

    252. 

  252.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    253. 

  253.         /// <returns>返回 0 至 100 之间的可能性</returns>

    254. 

  254.         internal virtual int GBKProbability(sbyte[] rawtext)

    255. 

  255.         {

    256. 

  256.             int i, rawtextlen = 0;

    257. 

  257. 

    258. 

  258.             int dbchars = 1, gbchars = 1;

    259. 

  259.             long gbfreq = 0, totalfreq = 1;

    260. 

  260.             float rangeval = 0, freqval = 0;

    261. 

  261.             int row, column;

    262. 

  262. 

    263. 

  263.             // Stage 1:  Check to see if characters fit into acceptable ranges

    264. 

  264.             rawtextlen = rawtext.Length;

    265. 

  265.             for (i = 0; i < rawtextlen - 1; i++)

    266. 

  266.             {

    267. 

  267.                 if (rawtext[i] >= 0)

    268. 

  268.                 {

    269. 

  269.                     //asciichars++;

    270. 

  270.                 }

    271. 

  271.                 else

    272. 

  272.                 {

    273. 

  273.                     dbchars++;

    274. 

  274.                     if ((sbyte)Identity(0xA1) <= rawtext[i] && rawtext[i] <= (sbyte)Identity(0xF7) && (sbyte)Identity(0xA1) <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)Identity(0xFE))

    275. 

  275.                     {

    276. 

  276.                         gbchars++;

    277. 

  277.                         totalfreq += 500;

    278. 

  278.                         row = rawtext[i] + 256 - 0xA1;

    279. 

  279.                         column = rawtext[i + 1] + 256 - 0xA1;

    280. 

  280. 

    281. 

  281.                         if (GBFreq[row][column] != 0)

    282. 

  282.                         {

    283. 

  283.                             gbfreq += GBFreq[row][column];

    284. 

  284.                         }

    285. 

  285.                         else if (15 <= row && row < 55)

    286. 

  286.                         {

    287. 

  287.                             gbfreq += 200;

    288. 

  288.                         }

    289. 

  289.                     }

    290. 

  290.                     else if ((sbyte)Identity(0x81) <= rawtext[i] && rawtext[i] <= (sbyte)Identity(0xFE) && (((sbyte)Identity(0x80) <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)Identity(0xFE)) || ((sbyte)0x40 <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)0x7E)))

    291. 

  291.                     {

    292. 

  292.                         gbchars++;

    293. 

  293.                         totalfreq += 500;

    294. 

  294.                         row = rawtext[i] + 256 - 0x81;

    295. 

  295.                         if (0x40 <= rawtext[i + 1] && rawtext[i + 1] <= 0x7E)

    296. 

  296.                         {

    297. 

  297.                             column = rawtext[i + 1] - 0x40;

    298. 

  298.                         }

    299. 

  299.                         else

    300. 

  300.                         {

    301. 

  301.                             column = rawtext[i + 1] + 256 - 0x80;

    302. 

  302.                         }

    303. 

  303. 

    304. 

  304.                         if (GBKFreq[row][column] != 0)

    305. 

  305.                         {

    306. 

  306.                             gbfreq += GBKFreq[row][column];

    307. 

  307.                         }

    308. 

  308.                     }

    309. 

  309.                     i++;

    310. 

  310.                 }

    311. 

  311.             }

    312. 

  312. 

    313. 

  313.             rangeval = 50 * ((float)gbchars / (float)dbchars);

    314. 

  314.             freqval = 50 * ((float)gbfreq / (float)totalfreq);

    315. 

  315. 

    316. 

  316.             return (int)(rangeval + freqval) - 1;

    317. 

  317.         }

    318. 

  318. 

    319. 

  319.         #endregion

    320. 

  320. 

    321. 

  321.         #region HZProbability.....

    322. 

  322. 

    323. 

  323.         /// <summary>

    324. 

  324.         /// 判断是HZ编码的可能性

    325. 

  325.         /// </summary>

    326. 

  326.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    327. 

  327.         /// <returns>返回 0 至 100 之间的可能性</returns>

    328. 

  328.         internal virtual int HZProbability(sbyte[] rawtext)

    329. 

  329.         {

    330. 

  330.             int i, rawtextlen;

    331. 

  331.             int hzchars = 0, dbchars = 1;

    332. 

  332.             long hzfreq = 0, totalfreq = 1;

    333. 

  333.             float rangeval = 0, freqval = 0;

    334. 

  334.             int hzstart = 0, hzend = 0;

    335. 

  335.             int row, column;

    336. 

  336. 

    337. 

  337.             rawtextlen = rawtext.Length;

    338. 

  338. 

    339. 

  339.             for (i = 0; i < rawtextlen; i++)

    340. 

  340.             {

    341. 

  341.                 if (rawtext[i] == '~')

    342. 

  342.                 {

    343. 

  343.                     if (rawtext[i + 1] == '{')

    344. 

  344.                     {

    345. 

  345.                         hzstart++;

    346. 

  346.                         i += 2;

    347. 

  347.                         while (i < rawtextlen - 1)

    348. 

  348.                         {

    349. 

  349.                             if (rawtext[i] == 0x0A || rawtext[i] == 0x0D)

    350. 

  350.                             {

    351. 

  351.                                 break;

    352. 

  352.                             }

    353. 

  353.                             else if (rawtext[i] == '~' && rawtext[i + 1] == '}')

    354. 

  354.                             {

    355. 

  355.                                 hzend++;

    356. 

  356.                                 i++;

    357. 

  357.                                 break;

    358. 

  358.                             }

    359. 

  359.                             else if ((0x21 <= rawtext[i] && rawtext[i] <= 0x77) && (0x21 <= rawtext[i + 1] && rawtext[i + 1] <= 0x77))

    360. 

  360.                             {

    361. 

  361.                                 hzchars += 2;

    362. 

  362.                                 row = rawtext[i] - 0x21;

    363. 

  363.                                 column = rawtext[i + 1] - 0x21;

    364. 

  364.                                 totalfreq += 500;

    365. 

  365.                                 if (GBFreq[row][column] != 0)

    366. 

  366.                                 {

    367. 

  367.                                     hzfreq += GBFreq[row][column];

    368. 

  368.                                 }

    369. 

  369.                                 else if (15 <= row && row < 55)

    370. 

  370.                                 {

    371. 

  371.                                     hzfreq += 200;

    372. 

  372.                                 }

    373. 

  373.                             }

    374. 

  374.                             else if (((byte)0xA1 <= rawtext[i] && rawtext[i] <= (byte)0xF7) && ((byte)0xA1 <= rawtext[i + 1] && rawtext[i + 1] <= (byte)0xF7))

    375. 

  375.                             {

    376. 

  376.                                 hzchars += 2;

    377. 

  377.                                 row = rawtext[i] + 256 - 0xA1;

    378. 

  378.                                 column = rawtext[i + 1] + 256 - 0xA1;

    379. 

  379.                                 totalfreq += 500;

    380. 

  380.                                 if (GBFreq[row][column] != 0)

    381. 

  381.                                 {

    382. 

  382.                                     hzfreq += GBFreq[row][column];

    383. 

  383.                                 }

    384. 

  384.                                 else if (15 <= row && row < 55)

    385. 

  385.                                 {

    386. 

  386.                                     hzfreq += 200;

    387. 

  387.                                 }

    388. 

  388.                             }

    389. 

  389.                             dbchars += 2;

    390. 

  390.                             i += 2;

    391. 

  391.                         }

    392. 

  392.                     }

    393. 

  393.                     else if (rawtext[i + 1] == '}')

    394. 

  394.                     {

    395. 

  395.                         hzend++;

    396. 

  396.                         i++;

    397. 

  397.                     }

    398. 

  398.                     else if (rawtext[i + 1] == '~')

    399. 

  399.                     {

    400. 

  400.                         i++;

    401. 

  401.                     }

    402. 

  402.                 }

    403. 

  403.             }

    404. 

  404. 

    405. 

  405.             if (hzstart > 4)

    406. 

  406.             {

    407. 

  407.                 rangeval = 50;

    408. 

  408.             }

    409. 

  409.             else if (hzstart > 1)

    410. 

  410.             {

    411. 

  411.                 rangeval = 41;

    412. 

  412.             }

    413. 

  413.             else if (hzstart > 0)

    414. 

  414.             {

    415. 

  415.                 // Only 39 in case the sequence happened to occur

    416. 

  416.                 rangeval = 39; // in otherwise non-Hz text

    417. 

  417.             }

    418. 

  418.             else

    419. 

  419.             {

    420. 

  420.                 rangeval = 0;

    421. 

  421.             }

    422. 

  422.             freqval = 50 * ((float)hzfreq / (float)totalfreq);

    423. 

  423. 

    424. 

  424. 

    425. 

  425.             return (int)(rangeval + freqval);

    426. 

  426.         }

    427. 

  427. 

    428. 

  428.         #endregion

    429. 

  429. 

    430. 

  430.         #region BIG5Probability.....

    431. 

  431. 

    432. 

  432.         /// <summary>

    433. 

  433.         /// 判断是BIG5编码的可能性

    434. 

  434.         /// </summary>

    435. 

  435.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    436. 

  436.         /// <returns>返回 0 至 100 之间的可能性</returns>

    437. 

  437.         internal virtual int BIG5Probability(sbyte[] rawtext)

    438. 

  438.         {

    439. 

  439.             int i, rawtextlen = 0;

    440. 

  440.             int dbchars = 1, bfchars = 1;

    441. 

  441.             float rangeval = 0, freqval = 0;

    442. 

  442.             long bffreq = 0, totalfreq = 1;

    443. 

  443.             int row, column;

    444. 

  444. 

    445. 

  445.             // Check to see if characters fit into acceptable ranges

    446. 

  446. 

    447. 

  447.             rawtextlen = rawtext.Length;

    448. 

  448.             for (i = 0; i < rawtextlen - 1; i++)

    449. 

  449.             {

    450. 

  450.                 if (rawtext[i] >= 0)

    451. 

  451.                 {

    452. 

  452.                     //asciichars++;

    453. 

  453.                 }

    454. 

  454.                 else

    455. 

  455.                 {

    456. 

  456.                     dbchars++;

    457. 

  457.                     if ((sbyte)Identity(0xA1) <= rawtext[i] && rawtext[i] <= (sbyte)Identity(0xF9) && (((sbyte)0x40 <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)0x7E) || ((sbyte)Identity(0xA1) <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)Identity(0xFE))))

    458. 

  458.                     {

    459. 

  459.                         bfchars++;

    460. 

  460.                         totalfreq += 500;

    461. 

  461.                         row = rawtext[i] + 256 - 0xA1;

    462. 

  462.                         if (0x40 <= rawtext[i + 1] && rawtext[i + 1] <= 0x7E)

    463. 

  463.                         {

    464. 

  464.                             column = rawtext[i + 1] - 0x40;

    465. 

  465.                         }

    466. 

  466.                         else

    467. 

  467.                         {

    468. 

  468.                             column = rawtext[i + 1] + 256 - 0x61;

    469. 

  469.                         }

    470. 

  470.                         if (Big5Freq[row][column] != 0)

    471. 

  471.                         {

    472. 

  472.                             bffreq += Big5Freq[row][column];

    473. 

  473.                         }

    474. 

  474.                         else if (3 <= row && row <= 37)

    475. 

  475.                         {

    476. 

  476.                             bffreq += 200;

    477. 

  477.                         }

    478. 

  478.                     }

    479. 

  479.                     i++;

    480. 

  480.                 }

    481. 

  481.             }

    482. 

  482. 

    483. 

  483.             rangeval = 50 * ((float)bfchars / (float)dbchars);

    484. 

  484.             freqval = 50 * ((float)bffreq / (float)totalfreq);

    485. 

  485. 

    486. 

  486. 

    487. 

  487.             return (int)(rangeval + freqval);

    488. 

  488.         }

    489. 

  489. 

    490. 

  490.         #endregion

    491. 

  491. 

    492. 

  492.         #region ENCTWProbability.....

    493. 

  493. 

    494. 

  494.         /// <summary>

    495. 

  495.         /// 判断是CNS11643(台湾)编码的可能性

    496. 

  496.         /// </summary>

    497. 

  497.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    498. 

  498.         /// <returns>返回 0 至 100 之间的可能性</returns>

    499. 

  499.         internal virtual int ENCTWProbability(sbyte[] rawtext)

    500. 

  500.         {

    501. 

  501.             int i, rawtextlen = 0;

    502. 

  502.             int dbchars = 1, cnschars = 1;

    503. 

  503.             long cnsfreq = 0, totalfreq = 1;

    504. 

  504.             float rangeval = 0, freqval = 0;

    505. 

  505.             int row, column;

    506. 

  506. 

    507. 

  507.             // Check to see if characters fit into acceptable ranges

    508. 

  508.             // and have expected frequency of use

    509. 

  509. 

    510. 

  510.             rawtextlen = rawtext.Length;

    511. 

  511.             for (i = 0; i < rawtextlen - 1; i++)

    512. 

  512.             {

    513. 

  513.                 if (rawtext[i] >= 0)

    514. 

  514.                 {

    515. 

  515.                     // in ASCII range

    516. 

  516.                     //asciichars++;

    517. 

  517.                 }

    518. 

  518.                 else

    519. 

  519.                 {

    520. 

  520.                     // high bit set

    521. 

  521.                     dbchars++;

    522. 

  522.                     if (i + 3 < rawtextlen && (sbyte)Identity(0x8E) == rawtext[i] && (sbyte)Identity(0xA1) <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)Identity(0xB0) && (sbyte)Identity(0xA1) <= rawtext[i + 2] && rawtext[i + 2] <= (sbyte)Identity(0xFE) && (sbyte)Identity(0xA1) <= rawtext[i + 3] && rawtext[i + 3] <= (sbyte)Identity(0xFE))

    523. 

  523.                     {

    524. 

  524.                         // Planes 1 - 16

    525. 

  525. 

    526. 

  526.                         cnschars++;

    527. 

  527.                         // These are all less frequent chars so just ignore freq

    528. 

  528.                         i += 3;

    529. 

  529.                     }

    530. 

  530.                     else if ((sbyte)Identity(0xA1) <= rawtext[i] && rawtext[i] <= (sbyte)Identity(0xFE) && (sbyte)Identity(0xA1) <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)Identity(0xFE))

    531. 

  531.                     {

    532. 

  532.                         cnschars++;

    533. 

  533.                         totalfreq += 500;

    534. 

  534.                         row = rawtext[i] + 256 - 0xA1;

    535. 

  535.                         column = rawtext[i + 1] + 256 - 0xA1;

    536. 

  536.                         if (EUC_TWFreq[row][column] != 0)

    537. 

  537.                         {

    538. 

  538.                             cnsfreq += EUC_TWFreq[row][column];

    539. 

  539.                         }

    540. 

  540.                         else if (35 <= row && row <= 92)

    541. 

  541.                         {

    542. 

  542.                             cnsfreq += 150;

    543. 

  543.                         }

    544. 

  544.                         i++;

    545. 

  545.                     }

    546. 

  546.                 }

    547. 

  547.             }

    548. 

  548. 

    549. 

  549. 

    550. 

  550.             rangeval = 50 * ((float)cnschars / (float)dbchars);

    551. 

  551.             freqval = 50 * ((float)cnsfreq / (float)totalfreq);

    552. 

  552. 

    553. 

  553. 

    554. 

  554.             return (int)(rangeval + freqval);

    555. 

  555.         }

    556. 

  556. 

    557. 

  557.         #endregion

    558. 

  558. 

    559. 

  559.         #region ISO2022CNProbability.....

    560. 

  560. 

    561. 

  561.         /// <summary>

    562. 

  562.         /// 判断是ISO2022CN编码的可能性

    563. 

  563.         /// </summary>

    564. 

  564.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    565. 

  565.         /// <returns>返回 0 至 100 之间的可能性</returns>

    566. 

  566.         internal virtual int ISO2022CNProbability(sbyte[] rawtext)

    567. 

  567.         {

    568. 

  568.             int i, rawtextlen = 0;

    569. 

  569.             int dbchars = 1, isochars = 1;

    570. 

  570.             long isofreq = 0, totalfreq = 1;

    571. 

  571.             float rangeval = 0, freqval = 0;

    572. 

  572.             int row, column;

    573. 

  573. 

    574. 

  574.             // Check to see if characters fit into acceptable ranges

    575. 

  575.             // and have expected frequency of use

    576. 

  576. 

    577. 

  577.             rawtextlen = rawtext.Length;

    578. 

  578.             for (i = 0; i < rawtextlen - 1; i++)

    579. 

  579.             {

    580. 

  580.                 if (rawtext[i] == (sbyte)0x1B && i + 3 < rawtextlen)

    581. 

  581.                 {

    582. 

  582.                     // Escape char ESC

    583. 

  583.                     if (rawtext[i + 1] == (sbyte)0x24 && rawtext[i + 2] == 0x29 && rawtext[i + 3] == (sbyte)0x41)

    584. 

  584.                     {

    585. 

  585.                         // GB Escape  $ ) A

    586. 

  586.                         i += 4;

    587. 

  587.                         while (rawtext[i] != (sbyte)0x1B)

    588. 

  588.                         {

    589. 

  589.                             dbchars++;

    590. 

  590.                             if ((0x21 <= rawtext[i] && rawtext[i] <= 0x77) && (0x21 <= rawtext[i + 1] && rawtext[i + 1] <= 0x77))

    591. 

  591.                             {

    592. 

  592.                                 isochars++;

    593. 

  593.                                 row = rawtext[i] - 0x21;

    594. 

  594.                                 column = rawtext[i + 1] - 0x21;

    595. 

  595.                                 totalfreq += 500;

    596. 

  596.                                 if (GBFreq[row][column] != 0)

    597. 

  597.                                 {

    598. 

  598.                                     isofreq += GBFreq[row][column];

    599. 

  599.                                 }

    600. 

  600.                                 else if (15 <= row && row < 55)

    601. 

  601.                                 {

    602. 

  602.                                     isofreq += 200;

    603. 

  603.                                 }

    604. 

  604.                                 i++;

    605. 

  605.                             }

    606. 

  606.                             i++;

    607. 

  607.                         }

    608. 

  608.                     }

    609. 

  609.                     else if (i + 3 < rawtextlen && rawtext[i + 1] == (sbyte)0x24 && rawtext[i + 2] == (sbyte)0x29 && rawtext[i + 3] == (sbyte)0x47)

    610. 

  610.                     {

    611. 

  611.                         // CNS Escape $ ) G

    612. 

  612.                         i += 4;

    613. 

  613.                         while (rawtext[i] != (sbyte)0x1B)

    614. 

  614.                         {

    615. 

  615.                             dbchars++;

    616. 

  616.                             if ((sbyte)0x21 <= rawtext[i] && rawtext[i] <= (sbyte)0x7E && (sbyte)0x21 <= rawtext[i + 1] && rawtext[i + 1] <= (sbyte)0x7E)

    617. 

  617.                             {

    618. 

  618.                                 isochars++;

    619. 

  619.                                 totalfreq += 500;

    620. 

  620.                                 row = rawtext[i] - 0x21;

    621. 

  621.                                 column = rawtext[i + 1] - 0x21;

    622. 

  622.                                 if (EUC_TWFreq[row][column] != 0)

    623. 

  623.                                 {

    624. 

  624.                                     isofreq += EUC_TWFreq[row][column];

    625. 

  625.                                 }

    626. 

  626.                                 else if (35 <= row && row <= 92)

    627. 

  627.                                 {

    628. 

  628.                                     isofreq += 150;

    629. 

  629.                                 }

    630. 

  630.                                 i++;

    631. 

  631.                             }

    632. 

  632.                             i++;

    633. 

  633.                         }

    634. 

  634.                     }

    635. 

  635.                     if (rawtext[i] == (sbyte)0x1B && i + 2 < rawtextlen && rawtext[i + 1] == (sbyte)0x28 && rawtext[i + 2] == (sbyte)0x42)

    636. 

  636.                     {

    637. 

  637.                         // ASCII:  ESC ( B

    638. 

  638.                         i += 2;

    639. 

  639.                     }

    640. 

  640.                 }

    641. 

  641.             }

    642. 

  642. 

    643. 

  643.             rangeval = 50 * ((float)isochars / (float)dbchars);

    644. 

  644.             freqval = 50 * ((float)isofreq / (float)totalfreq);

    645. 

  645. 

    646. 

  646.             return (int)(rangeval + freqval);

    647. 

  647.         }

    648. 

  648. 

    649. 

  649.         #endregion

    650. 

  650. 

    651. 

  651.         #region UTF8Probability.....

    652. 

  652. 

    653. 

  653.         /// <summary>

    654. 

  654.         /// 判断是UTF8编码的可能性

    655. 

  655.         /// </summary>

    656. 

  656.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    657. 

  657.         /// <returns>返回 0 至 100 之间的可能性</returns>

    658. 

  658.         internal virtual int UTF8Probability(sbyte[] rawtext)

    659. 

  659.         {

    660. 

  660.             int score = 0;

    661. 

  661.             int i, rawtextlen = 0;

    662. 

  662.             int goodbytes = 0, asciibytes = 0;

    663. 

  663. 

    664. 

  664.             // Maybe also use UTF8 Byte Order Mark:  EF BB BF

    665. 

  665. 

    666. 

  666.             // Check to see if characters fit into acceptable ranges

    667. 

  667.             rawtextlen = rawtext.Length;

    668. 

  668.             for (i = 0; i < rawtextlen; i++)

    669. 

  669.             {

    670. 

  670.                 if ((rawtext[i] & (sbyte)0x7F) == rawtext[i])

    671. 

  671.                 {

    672. 

  672.                     // One byte

    673. 

  673.                     asciibytes++;

    674. 

  674.                     // Ignore ASCII, can throw off count

    675. 

  675.                 }

    676. 

  676.                 else if (-64 <= rawtext[i] && rawtext[i] <= -33 && i + 1 < rawtextlen && -128 <= rawtext[i + 1] && rawtext[i + 1] <= -65)

    677. 

  677.                 {

    678. 

  678.                     goodbytes += 2;

    679. 

  679.                     i++;

    680. 

  680.                 }

    681. 

  681.                 else if (-32 <= rawtext[i] && rawtext[i] <= -17 && i + 2 < rawtextlen && -128 <= rawtext[i + 1] && rawtext[i + 1] <= -65 && -128 <= rawtext[i + 2] && rawtext[i + 2] <= -65)

    682. 

  682.                 {

    683. 

  683.                     goodbytes += 3;

    684. 

  684.                     i += 2;

    685. 

  685.                 }

    686. 

  686.             }

    687. 

  687. 

    688. 

  688.             if (asciibytes == rawtextlen)

    689. 

  689.             {

    690. 

  690.                 return 0;

    691. 

  691.             }

    692. 

  692. 

    693. 

  693.             score = (int)(100 * ((float)goodbytes / (float)(rawtextlen - asciibytes)));

    694. 

  694. 

    695. 

  695.             // If not above 98, reduce to zero to prevent coincidental matches

    696. 

  696.             // Allows for some (few) bad formed sequences

    697. 

  697.             if (score > 98)

    698. 

  698.             {

    699. 

  699.                 return score;

    700. 

  700.             }

    701. 

  701.             else if (score > 95 && goodbytes > 30)

    702. 

  702.             {

    703. 

  703.                 return score;

    704. 

  704.             }

    705. 

  705.             else

    706. 

  706.             {

    707. 

  707.                 return 0;

    708. 

  708.             }

    709. 

  709.         }

    710. 

  710. 

    711. 

  711.         #endregion

    712. 

  712. 

    713. 

  713.         #region UnicodeProbability.....

    714. 

  714. 

    715. 

  715.         /// <summary>

    716. 

  716.         /// 判断是Unicode编码的可能性

    717. 

  717.         /// </summary>

    718. 

  718.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    719. 

  719.         /// <returns>返回 0 至 100 之间的可能性</returns>

    720. 

  720.         internal virtual int UnicodeProbability(sbyte[] rawtext)

    721. 

  721.         {

    722. 

  722.             //int score = 0;

    723. 

  723.             //int i, rawtextlen = 0;

    724. 

  724.             //int goodbytes = 0, asciibytes = 0;

    725. 

  725. 

    726. 

  726.             if (((sbyte)Identity(0xFE) == rawtext[0] && (sbyte)Identity(0xFF) == rawtext[1]) || ((sbyte)Identity(0xFF) == rawtext[0] && (sbyte)Identity(0xFE) == rawtext[1]))

    727. 

  727.             {

    728. 

  728.                 return 100;

    729. 

  729.             }

    730. 

  730. 

    731. 

  731.             return 0;

    732. 

  732.         }

    733. 

  733. 

    734. 

  734.         #endregion

    735. 

  735. 

    736. 

  736.         #region ASCIIProbability.....

    737. 

  737. 

    738. 

  738.         /// <summary>

    739. 

  739.         /// 判断是ASCII编码的可能性

    740. 

  740.         /// </summary>

    741. 

  741.         /// <param name="rawtext">要判断的 <see cref="sbyte"/> 字节数组</param>

    742. 

  742.         /// <returns>返回 0 至 100 之间的可能性</returns>

    743. 

  743.         internal virtual int ASCIIProbability(sbyte[] rawtext)

    744. 

  744.         {

    745. 

  745.             int score = 70;

    746. 

  746.             int i, rawtextlen;

    747. 

  747. 

    748. 

  748.             rawtextlen = rawtext.Length;

    749. 

  749. 

    750. 

  750.             for (i = 0; i < rawtextlen; i++)

    751. 

  751.             {

    752. 

  752.                 if (rawtext[i] < 0)

    753. 

  753.                 {

    754. 

  754.                     score = score - 5;

    755. 

  755.                 }

    756. 

  756.                 else if (rawtext[i] == (sbyte)0x1B)

    757. 

  757.                 {

    758. 

  758.                     // ESC (used by ISO 2022)

    759. 

  759.                     score = score - 5;

    760. 

  760.                 }

    761. 

  761.             }

    762. 

  762. 

    763. 

  763.             return score;

    764. 

  764.         }

    765. 

  765. 

    766. 

  766.         #endregion

    767. 

  767. 

    768. 

  768.         #endregion

    769. 

  769. 

    770. 

  770.         #region Initialize_Frequencies.....

    771. 

  771. 

    772. 

  772.         /// <summary>

    773. 

  773.         /// 初始化必要的条件

    774. 

  774.         /// </summary>

    775. 

  775.         internal virtual void Initialize_Frequencies()

    776. 

  776.         {

    777. 

  777.             int i;

    778. 

  778.             if (GBFreq[0] == null)

    779. 

  779.             {

    780. 

  780.                 for (i = 0; i < 94; i++)

    781. 

  781.                 {

    782. 

  782.                     GBFreq[i] = new int[94];

    783. 

  783.                 }

    784. 

  784. 

    785. 

  785.                 #region GBFreq[20][35] = 599;

    786. 

  786. 

    787. 

  787.                 GBFreq[49][26] = 598;

    788. 

  788.                 GBFreq[41][38] = 597;

    789. 

  789.                 GBFreq[17][26] = 596;

    790. 

  790.                 GBFreq[32][42] = 595;

    791. 

  791.                 GBFreq[39][42] = 594;

    792. 

  792.                 GBFreq[45][49] = 593;

    793. 

  793.                 GBFreq[51][57] = 592;

    794. 

  794.                 GBFreq[50][47] = 591;

    795. 

  795.                 GBFreq[42][90] = 590;

    796. 

  796.                 GBFreq[52][65] = 589;

    797. 

  797.                 GBFreq[53][47] = 588;

    798. 

  798.                 GBFreq[19][82] = 587;

    799. 

  799.                 GBFreq[31][19] = 586;

    800. 

  800.                 GBFreq[40][46] = 585;

    801. 

  801.                 GBFreq[24][89] = 584;

    802. 

  802.                 GBFreq[23][85] = 583;

    803. 

  803.                 GBFreq[20][28] = 582;

    804. 

  804.                 GBFreq[42][20] = 581;

    805. 

  805.                 GBFreq[34][38] = 580;

    806. 

  806.                 GBFreq[45][9] = 579;

    807. 

  807.                 GBFreq[54][50] = 578;

    808. 

  808.                 GBFreq[25][44] = 577;

    809. 

  809.                 GBFreq[35][66] = 576;

    810. 

  810.                 GBFreq[20][55] = 575;

    811. 

  811.                 GBFreq[18][85] = 574;

    812. 

  812.                 GBFreq[20][31] = 573;

    813. 

  813.                 GBFreq[49][17] = 572;

    814. 

  814.                 GBFreq[41][16] = 571;

    815. 

  815.                 GBFreq[35][73] = 570;

    816. 

  816.                 GBFreq[20][34] = 569;

    817. 

  817.                 GBFreq[29][44] = 568;

    818. 

  818.                 GBFreq[35][38] = 567;

    819. 

  819.                 GBFreq[49][9] = 566;

    820. 

  820.                 GBFreq[46][33] = 565;

    821. 

  821.                 GBFreq[49][51] = 564;

    822. 

  822.                 GBFreq[40][89] = 563;

    823. 

  823.                 GBFreq[26][64] = 562;

    824. 

  824.                 GBFreq[54][51] = 561;

    825. 

  825.                 GBFreq[54][36] = 560;

    826. 

  826.                 GBFreq[39][4] = 559;

    827. 

  827.                 GBFreq[53][13] = 558;

    828. 

  828.                 GBFreq[24][92] = 557;

    829. 

  829.                 GBFreq[27][49] = 556;

    830. 

  830.                 GBFreq[48][6] = 555;

    831. 

  831.                 GBFreq[21][51] = 554;

    832. 

  832.                 GBFreq[30][40] = 553;

    833. 

  833.                 GBFreq[42][92] = 552;

    834. 

  834.                 GBFreq[31][78] = 551;

    835. 

  835.                 GBFreq[25][82] = 550;

    836. 

  836.                 GBFreq[47][0] = 549;

    837. 

  837.                 GBFreq[34][19] = 548;

    838. 

  838.                 GBFreq[47][35] = 547;

    839. 

  839.                 GBFreq[21][63] = 546;

    840. 

  840.                 GBFreq[43][75] = 545;

    841. 

  841.                 GBFreq[21][87] = 544;

    842. 

  842.                 GBFreq[35][59] = 543;

    843. 

  843.                 GBFreq[25][34] = 542;

    844. 

  844.                 GBFreq[21][27] = 541;

    845. 

  845.                 GBFreq[39][26] = 540;

    846. 

  846.                 GBFreq[34][26] = 539;

    847. 

  847.                 GBFreq[39][52] = 538;

    848. 

  848.                 GBFreq[50][57] = 537;

    849. 

  849.                 GBFreq[37][79] = 536;

    850. 

  850.                 GBFreq[26][24] = 535;

    851. 

  851.                 GBFreq[22][1] = 534;

    852. 

  852.                 GBFreq[18][40] = 533;

    853. 

  853.                 GBFreq[41][33] = 532;

    854. 

  854.                 GBFreq[53][26] = 531;

    855. 

  855.                 GBFreq[54][86] = 530;

    856. 

  856.                 GBFreq[20][16] = 529;

    857. 

  857.                 GBFreq[46][74] = 528;

    858. 

  858.                 GBFreq[30][19] = 527;

    859. 

  859.                 GBFreq[45][35] = 526;

    860. 

  860.                 GBFreq[45][61] = 525;

    861. 

  861.                 GBFreq[30][9] = 524;

    862. 

  862.                 GBFreq[41][53] = 523;

    863. 

  863.                 GBFreq[41][13] = 522;

    864. 

  864.                 GBFreq[50][34] = 521;

    865. 

  865.                 GBFreq[53][86] = 520;

    866. 

  866.                 GBFreq[47][47] = 519;

    867. 

  867.                 GBFreq[22][28] = 518;

    868. 

  868.                 GBFreq[50][53] = 517;

    869. 

  869.                 GBFreq[39][70] = 516;

    870. 

  870.                 GBFreq[38][15] = 515;

    871. 

  871.                 GBFreq[42][88] = 514;

    872. 

  872.                 GBFreq[16][29] = 513;

    873. 

  873.                 GBFreq[27][90] = 512;

    874. 

  874.                 GBFreq[29][12] = 511;

    875. 

  875.                 GBFreq[44][22] = 510;

    876. 

  876.                 GBFreq[34][69] = 509;

    877. 

  877.                 GBFreq[24][10] = 508;

    878. 

  878.                 GBFreq[44][11] = 507;

    879. 

  879.                 GBFreq[39][92] = 506;

    880. 

  880.                 GBFreq[49][48] = 505;

    881. 

  881.                 GBFreq[31][46] = 504;

    882. 

  882.                 GBFreq[19][50] = 503;

    883. 

  883.                 GBFreq[21][14] = 502;

    884. 

  884.                 GBFreq[32][28] = 501;

    885. 

  885.                 GBFreq[18][3] = 500;

    886. 

  886.                 GBFreq[53][9] = 499;

    887. 

  887.                 GBFreq[34][80] = 498;

    888. 

  888.                 GBFreq[48][88] = 497;

    889. 

  889.                 GBFreq[46][53] = 496;

    890. 

  890.                 GBFreq[22][53] = 495;

    891. 

  891.                 GBFreq[28][10] = 494;

    892. 

  892.                 GBFreq[44][65] = 493;

    893. 

  893.                 GBFreq[20][10] = 492;

    894. 

  894.                 GBFreq[40][76] = 491;

    895. 

  895.                 GBFreq[47][8] = 490;

    896. 

  896.                 GBFreq[50][74] = 489;

    897. 

  897.                 GBFreq[23][62] = 488;

    898. 

  898.                 GBFreq[49][65] = 487;

    899. 

  899.                 GBFreq[28][87] = 486;

    900. 

  900.                 GBFreq[15][48] = 485;

    901. 

  901.                 GBFreq[22][7] = 484;

    902. 

  902.                 GBFreq[19][42] = 483;

    903. 

  903.                 GBFreq[41][20] = 482;

    904. 

  904.                 GBFreq[26][55] = 481;

    905. 

  905.                 GBFreq[21][93] = 480;

    906. 

  906.                 GBFreq[31][76] = 479;

    907. 

  907.                 GBFreq[34][31] = 478;

    908. 

  908.                 GBFreq[20][66] = 477;

    909. 

  909.                 GBFreq[51][33] = 476;

    910. 

  910.                 GBFreq[34][86] = 475;

    911. 

  911.                 GBFreq[37][67] = 474;

    912. 

  912.                 GBFreq[53][53] = 473;

    913. 

  913.                 GBFreq[40][88] = 472;

    914. 

  914.                 GBFreq[39][10] = 471;

    915. 

  915.                 GBFreq[24][3] = 470;

    916. 

  916.                 GBFreq[27][25] = 469;

    917. 

  917.                 GBFreq[26][15] = 468;

    918. 

  918.                 GBFreq[21][88] = 467;

    919. 

  919.                 GBFreq[52][62] = 466;

    920. 

  920.                 GBFreq[46][81] = 465;

    921. 

  921.                 GBFreq[38][72] = 464;

    922. 

  922.                 GBFreq[17][30] = 463;

    923. 

  923.                 GBFreq[52][92] = 462;

    924. 

  924.                 GBFreq[34][90] = 461;

    925. 

  925.                 GBFreq[21][7] = 460;

    926. 

  926.                 GBFreq[36][13] = 459;

    927. 

  927.                 GBFreq[45][41] = 458;

    928. 

  928.                 GBFreq[32][5] = 457;

    929. 

  929.                 GBFreq[26][89] = 456;

    930. 

  930.                 GBFreq[23][87] = 455;

    931. 

  931.                 GBFreq[20][39] = 454;

    932. 

  932.                 GBFreq[27][23] = 453;

    933. 

  933.                 GBFreq[25][59] = 452;

    934. 

  934.                 GBFreq[49][20] = 451;

    935. 

  935.                 GBFreq[54][77] = 450;

    936. 

  936.                 GBFreq[27][67] = 449;

    937. 

  937.                 GBFreq[47][33] = 448;

    938. 

  938.                 GBFreq[41][17] = 447;

    939. 

  939.                 GBFreq[19][81] = 446;

    940. 

  940.                 GBFreq[16][66] = 445;

    941. 

  941.                 GBFreq[45][26] = 444;

    942. 

  942.                 GBFreq[49][81] = 443;

    943. 

  943.                 GBFreq[53][55] = 442;

    944. 

  944.                 GBFreq[16][26] = 441;

    945. 

  945.                 GBFreq[54][62] = 440;

    946. 

  946.                 GBFreq[20][70] = 439;

    947. 

  947.                 GBFreq[42][35] = 438;

    948. 

  948.                 GBFreq[20][57] = 437;

    949. 

  949.                 GBFreq[34][36] = 436;

    950. 

  950.                 GBFreq[46][63] = 435;

    951. 

  951.                 GBFreq[19][45] = 434;

    952. 

  952.                 GBFreq[21][10] = 433;

    953. 

  953.                 GBFreq[52][93] = 432;

    954. 

  954.                 GBFreq[25][2] = 431;

    955. 

  955.                 GBFreq[30][57] = 430;

    956. 

  956.                 GBFreq[41][24] = 429;

    957. 

  957.                 GBFreq[28][43] = 428;

    958. 

  958.                 GBFreq[45][86] = 427;

    959. 

  959.                 GBFreq[51][56] = 426;

    960. 

  960.                 GBFreq[37][28] = 425;

    961. 

  961.                 GBFreq[52][69] = 424;

    962. 

  962.                 GBFreq[43][92] = 423;

    963. 

  963.                 GBFreq[41][31] = 422;

    964. 

  964.                 GBFreq[37][87] = 421;

    965. 

  965.                 GBFreq[47][36] = 420;

    966. 

  966.                 GBFreq[16][16] = 419;

    967. 

  967.                 GBFreq[40][56] = 418;

    968. 

  968.                 GBFreq[24][55] = 417;

    969. 

  969.                 GBFreq[17][1] = 416;

    970. 

  970.                 GBFreq[35][57] = 415;

    971. 

  971.                 GBFreq[27][50] = 414;

    972. 

  972.                 GBFreq[26][14] = 413;

    973. 

  973.                 GBFreq[50][40] = 412;

    974. 

  974.                 GBFreq[39][19] = 411;

    975. 

  975.                 GBFreq[19][89] = 410;

    976. 

  976.                 GBFreq[29][91] = 409;

    977. 

  977.                 GBFreq[17][89] = 408;

    978. 

  978.                 GBFreq[39][74] = 407;

    979. 

  979.                 GBFreq[46][39] = 406;

    980. 

  980.                 GBFreq[40][28] = 405;

    981. 

  981.                 GBFreq[45][68] = 404;

    982. 

  982.                 GBFreq[43][10] = 403;

    983. 

  983.                 GBFreq[42][13] = 402;

    984. 

  984.                 GBFreq[44][81] = 401;

    985. 

  985.                 GBFreq[41][47] = 400;

    986. 

  986.                 GBFreq[48][58] = 399;

    987. 

  987.                 GBFreq[43][68] = 398;

    988. 

  988.                 GBFreq[16][79] = 397;

    989. 

  989.                 GBFreq[19][5] = 396;

    990. 

  990.                 GBFreq[54][59] = 395;

    991. 

  991.                 GBFreq[17][36] = 394;

    992. 

  992.                 GBFreq[18][0] = 393;

    993. 

  993.                 GBFreq[41][5] = 392;

    994. 

  994.                 GBFreq[41][72] = 391;

    995. 

  995.                 GBFreq[16][39] = 390;

    996. 

  996.                 GBFreq[54][0] = 389;

    997. 

  997.                 GBFreq[51][16] = 388;

    998. 

  998.                 GBFreq[29][36] = 387;

    999. 

  999.                 GBFreq[47][5] = 386;

    1000. 

  1000.                 GBFreq[47][51] = 385;

    1001. 

  1001.                 GBFreq[44][7] = 384;

    1002. 

  1002.                 GBFreq[35][30] = 383;

    1003. 

  1003.                 GBFreq[26][9] = 382;

    1004. 

  1004.                 GBFreq[16][7] = 381;

    1005. 

  1005.                 GBFreq[32][1] = 380;

    1006. 

  1006.                 GBFreq[33][76] = 379;

    1007. 

  1007.                 GBFreq[34][91] = 378;

    1008. 

  1008.                 GBFreq[52][36] = 377;

    1009. 

  1009.                 GBFreq[26][77] = 376;

    1010. 

  1010.                 GBFreq[35][48] = 375;

    1011. 

  1011.                 GBFreq[40][80] = 374;

    1012. 

  1012.                 GBFreq[41][92] = 373;

    1013. 

  1013.                 GBFreq[27][93] = 372;

    1014. 

  1014.                 GBFreq[15][17] = 371;

    1015. 

  1015.                 GBFreq[16][76] = 370;

    1016. 

  1016.                 GBFreq[51][12] = 369;

    1017. 

  1017.                 GBFreq[18][20] = 368;

    1018. 

  1018.                 GBFreq[15][54] = 367;

    1019. 

  1019.                 GBFreq[50][5] = 366;

    1020. 

  1020.                 GBFreq[33][22] = 365;

    1021. 

  1021.                 GBFreq[37][57] = 364;

    1022. 

  1022.                 GBFreq[28][47] = 363;

    1023. 

  1023.                 GBFreq[42][31] = 362;

    1024. 

  1024.                 GBFreq[18][2] = 361;

    1025. 

  1025.                 GBFreq[43][64] = 360;

    1026. 

  1026.                 GBFreq[23][47] = 359;

    1027. 

  1027.                 GBFreq[28][79] = 358;

    1028. 

  1028.                 GBFreq[25][45] = 357;

    1029. 

  1029.                 GBFreq[23][91] = 356;

    1030. 

  1030.                 GBFreq[22][19] = 355;

    1031. 

  1031.                 GBFreq[25][46] = 354;

    1032. 

  1032.                 GBFreq[22][36] = 353;

    1033. 

  1033.                 GBFreq[54][85] = 352;

    1034. 

  1034.                 GBFreq[46][20] = 351;

    1035. 

  1035.                 GBFreq[27][37] = 350;

    1036. 

  1036.                 GBFreq[26][81] = 349;

    1037. 

  1037.                 GBFreq[42][29] = 348;

    1038. 

  1038.                 GBFreq[31][90] = 347;

    1039. 

  1039.                 GBFreq[41][59] = 346;

    1040. 

  1040.                 GBFreq[24][65] = 345;

    1041. 

  1041.                 GBFreq[44][84] = 344;

    1042. 

  1042.                 GBFreq[24][90] = 343;

    1043. 

  1043.                 GBFreq[38][54] = 342;

    1044. 

  1044.                 GBFreq[28][70] = 341;

    1045. 

  1045.                 GBFreq[27][15] = 340;

    1046. 

  1046.                 GBFreq[28][80] = 339;

    1047. 

  1047.                 GBFreq[29][8] = 338;

    1048. 

  1048.                 GBFreq[45][80] = 337;

    1049. 

  1049.                 GBFreq[53][37] = 336;

    1050. 

  1050.                 GBFreq[28][65] = 335;

    1051. 

  1051.                 GBFreq[23][86] = 334;

    1052. 

  1052.                 GBFreq[39][45] = 333;

    1053. 

  1053.                 GBFreq[53][32] = 332;

    1054. 

  1054.                 GBFreq[38][68] = 331;

    1055. 

  1055.                 GBFreq[45][78] = 330;

    1056. 

  1056.                 GBFreq[43][7] = 329;

    1057. 

  1057.                 GBFreq[46][82] = 328;

    1058. 

  1058.                 GBFreq[27][38] = 327;

    1059. 

  1059.                 GBFreq[16][62] = 326;

    1060. 

  1060.                 GBFreq[24][17] = 325;

    1061. 

  1061.                 GBFreq[22][70] = 324;

    1062. 

  1062.                 GBFreq[52][28] = 323;

    1063. 

  1063.                 GBFreq[23][40] = 322;

    1064. 

  1064.                 GBFreq[28][50] = 321;

    1065. 

  1065.                 GBFreq[42][91] = 320;

    1066. 

  1066.                 GBFreq[47][76] = 319;

    1067. 

  1067.                 GBFreq[15][42] = 318;

    1068. 

  1068.                 GBFreq[43][55] = 317;

    1069. 

  1069.                 GBFreq[29][84] = 316;

    1070. 

  1070.                 GBFreq[44][90] = 315;

    1071. 

  1071.                 GBFreq[53][16] = 314;

    1072. 

  1072.                 GBFreq[22][93] = 313;

    1073. 

  1073.                 GBFreq[34][10] = 312;

    1074. 

  1074.                 GBFreq[32][53] = 311;

    1075. 

  1075.                 GBFreq[43][65] = 310;

    1076. 

  1076.                 GBFreq[28][7] = 309;

    1077. 

  1077.                 GBFreq[35][46] = 308;

    1078. 

  1078.                 GBFreq[21][39] = 307;

    1079. 

  1079.                 GBFreq[44][18] = 306;

    1080. 

  1080.                 GBFreq[40][10] = 305;

    1081. 

  1081.                 GBFreq[54][53] = 304;

    1082. 

  1082.                 GBFreq[38][74] = 303;

    1083. 

  1083.                 GBFreq[28][26] = 302;

    1084. 

  1084.                 GBFreq[15][13] = 301;

    1085. 

  1085.                 GBFreq[39][34] = 300;

    1086. 

  1086.                 GBFreq[39][46] = 299;

    1087. 

  1087.                 GBFreq[42][66] = 298;

    1088. 

  1088.                 GBFreq[33][58] = 297;

    1089. 

  1089.                 GBFreq[15][56] = 296;

    1090. 

  1090.                 GBFreq[18][51] = 295;

    1091. 

  1091.                 GBFreq[49][68] = 294;

    1092. 

  1092.                 GBFreq[30][37] = 293;

    1093. 

  1093.                 GBFreq[51][84] = 292;

    1094. 

  1094.                 GBFreq[51][9] = 291;

    1095. 

  1095.                 GBFreq[40][70] = 290;

    1096. 

  1096.                 GBFreq[41][84] = 289;

    1097. 

  1097.                 GBFreq[28][64] = 288;

    1098. 

  1098.                 GBFreq[32][88] = 287;

    1099. 

  1099.                 GBFreq[24][5] = 286;

    1100. 

  1100.                 GBFreq[53][23] = 285;

    1101. 

  1101.                 GBFreq[42][27] = 284;

    1102. 

  1102.                 GBFreq[22][38] = 283;

    1103. 

  1103.                 GBFreq[32][86] = 282;

    1104. 

  1104.                 GBFreq[34][30] = 281;

    1105. 

  1105.                 GBFreq[38][63] = 280;

    1106. 

  1106.                 GBFreq[24][59] = 279;

    1107. 

  1107.                 GBFreq[22][81] = 278;

    1108. 

  1108.                 GBFreq[32][11] = 277;

    1109. 

  1109.                 GBFreq[51][21] = 276;

    1110. 

  1110.                 GBFreq[54][41] = 275;

    1111. 

  1111.                 GBFreq[21][50] = 274;

    1112. 

  1112.                 GBFreq[23][89] = 273;

    1113. 

  1113.                 GBFreq[19][87] = 272;

    1114. 

  1114.                 GBFreq[26][7] = 271;

    1115. 

  1115.                 GBFreq[30][75] = 270;

    1116. 

  1116.                 GBFreq[43][84] = 269;

    1117. 

  1117.                 GBFreq[51][25] = 268;

    1118. 

  1118.                 GBFreq[16][67] = 267;

    1119. 

  1119.                 GBFreq[32][9] = 266;

    1120. 

  1120.                 GBFreq[48][51] = 265;

    1121. 

  1121.                 GBFreq[39][7] = 264;

    1122. 

  1122.                 GBFreq[44][88] = 263;

    1123. 

  1123.                 GBFreq[52][24] = 262;

    1124. 

  1124.                 GBFreq[23][34] = 261;

    1125. 

  1125.                 GBFreq[32][75] = 260;

    1126. 

  1126.                 GBFreq[19][10] = 259;

    1127. 

  1127.                 GBFreq[28][91] = 258;

    1128. 

  1128.                 GBFreq[32][83] = 257;

    1129. 

  1129.                 GBFreq[25][75] = 256;

    1130. 

  1130.                 GBFreq[53][45] = 255;

    1131. 

  1131.                 GBFreq[29][85] = 254;

    1132. 

  1132.                 GBFreq[53][59] = 253;

    1133. 

  1133.                 GBFreq[16][2] = 252;

    1134. 

  1134.                 GBFreq[19][78] = 251;

    1135. 

  1135.                 GBFreq[15][75] = 250;

    1136. 

  1136.                 GBFreq[51][42] = 249;

    1137. 

  1137.                 GBFreq[45][67] = 248;

    1138. 

  1138.                 GBFreq[15][74] = 247;

    1139. 

  1139.                 GBFreq[25][81] = 246;

    1140. 

  1140.                 GBFreq[37][62] = 245;

    1141. 

  1141.                 GBFreq[16][55] = 244;

    1142. 

  1142.                 GBFreq[18][38] = 243;

    1143. 

  1143.                 GBFreq[23][23] = 242;

    1144. 

  1144. 

    1145. 

  1145.                 GBFreq[38][30] = 241;

    1146. 

  1146.                 GBFreq[17][28] = 240;

    1147. 

  1147.                 GBFreq[44][73] = 239;

    1148. 

  1148.                 GBFreq[23][78] = 238;

    1149. 

  1149.                 GBFreq[40][77] = 237;

    1150. 

  1150.                 GBFreq[38][87] = 236;

    1151. 

  1151.                 GBFreq[27][19] = 235;

    1152. 

  1152.                 GBFreq[38][82] = 234;

    1153. 

  1153.                 GBFreq[37][22] = 233;

    1154. 

  1154.                 GBFreq[41][30] = 232;

    1155. 

  1155.                 GBFreq[54][9] = 231;

    1156. 

  1156.                 GBFreq[32][30] = 230;

    1157. 

  1157.                 GBFreq[30][52] = 229;

    1158. 

  1158.                 GBFreq[40][84] = 228;

    1159. 

  1159.                 GBFreq[53][57] = 227;

    1160. 

  1160.                 GBFreq[27][27] = 226;

    1161. 

  1161.                 GBFreq[38][64] = 225;

    1162. 

  1162.                 GBFreq[18][43] = 224;

    1163. 

  1163.                 GBFreq[23][69] = 223;

    1164. 

  1164.                 GBFreq[28][12] = 222;

    1165. 

  1165.                 GBFreq[50][78] = 221;

    1166. 

  1166.                 GBFreq[50][1] = 220;

    1167. 

  1167.                 GBFreq[26][88] = 219;

    1168. 

  1168.                 GBFreq[36][40] = 218;

    1169. 

  1169.                 GBFreq[33][89] = 217;

    1170. 

  1170.                 GBFreq[41][28] = 216;

    1171. 

  1171.                 GBFreq[31][77] = 215;

    1172. 

  1172.                 GBFreq[46][1] = 214;

    1173. 

  1173.                 GBFreq[47][19] = 213;

    1174. 

  1174.                 GBFreq[35][55] = 212;

    1175. 

  1175.                 GBFreq[41][21] = 211;

    1176. 

  1176.                 GBFreq[27][10] = 210;

    1177. 

  1177.                 GBFreq[32][77] = 209;

    1178. 

  1178.                 GBFreq[26][37] = 208;

    1179. 

  1179.                 GBFreq[20][33] = 207;

    1180. 

  1180.                 GBFreq[41][52] = 206;

    1181. 

  1181.                 GBFreq[32][18] = 205;

    1182. 

  1182.                 GBFreq[38][13] = 204;

    1183. 

  1183.                 GBFreq[20][18] = 203;

    1184. 

  1184.                 GBFreq[20][24] = 202;

    1185. 

  1185.                 GBFreq[45][19] = 201;

    1186. 

  1186.                 GBFreq[18][53] = 200;

    1187. 

  1187. 

    1188. 

  1188.                 #endregion

    1189. 

  1189.             }

    1190. 

  1190. 

    1191. 

  1191.             if (GBKFreq[0] == null)

    1192. 

  1192.             {

    1193. 

  1193.                 for (i = 0; i < 126; i++)

    1194. 

  1194.                 {

    1195. 

  1195.                     GBKFreq[i] = new int[191];

    1196. 

  1196.                 }

    1197. 

  1197. 

    1198. 

  1198.                 #region GBKFreq[52][132] = 600;

    1199. 

  1199. 

    1200. 

  1200.                 GBKFreq[73][135] = 599;

    1201. 

  1201.                 GBKFreq[49][123] = 598;

    1202. 

  1202.                 GBKFreq[77][146] = 597;

    1203. 

  1203.                 GBKFreq[81][123] = 596;

    1204. 

  1204.                 GBKFreq[82][144] = 595;

    1205. 

  1205.                 GBKFreq[51][179] = 594;

    1206. 

  1206.                 GBKFreq[83][154] = 593;

    1207. 

  1207.                 GBKFreq[71][139] = 592;

    1208. 

  1208.                 GBKFreq[64][139] = 591;

    1209. 

  1209.                 GBKFreq[85][144] = 590;

    1210. 

  1210.                 GBKFreq[52][125] = 589;

    1211. 

  1211.                 GBKFreq[88][25] = 588;

    1212. 

  1212.                 GBKFreq[81][106] = 587;

    1213. 

  1213.                 GBKFreq[81][148] = 586;

    1214. 

  1214.                 GBKFreq[62][137] = 585;

    1215. 

  1215.                 GBKFreq[94][0] = 584;

    1216. 

  1216.                 GBKFreq[1][64] = 583;

    1217. 

  1217.                 GBKFreq[67][163] = 582;

    1218. 

  1218.                 GBKFreq[20][190] = 581;

    1219. 

  1219.                 GBKFreq[57][131] = 580;

    1220. 

  1220.                 GBKFreq[29][169] = 579;

    1221. 

  1221.                 GBKFreq[72][143] = 578;

    1222. 

  1222.                 GBKFreq[0][173] = 577;

    1223. 

  1223.                 GBKFreq[11][23] = 576;

    1224. 

  1224.                 GBKFreq[61][141] = 575;

    1225. 

  1225.                 GBKFreq[60][123] = 574;

    1226. 

  1226.                 GBKFreq[81][114] = 573;

    1227. 

  1227.                 GBKFreq[82][131] = 572;

    1228. 

  1228.                 GBKFreq[67][156] = 571;

    1229. 

  1229.                 GBKFreq[71][167] = 570;

    1230. 

  1230.                 GBKFreq[20][50] = 569;

    1231. 

  1231.                 GBKFreq[77][132] = 568;

    1232. 

  1232.                 GBKFreq[84][38] = 567;

    1233. 

  1233.                 GBKFreq[26][29] = 566;

    1234. 

  1234.                 GBKFreq[74][187] = 565;

    1235. 

  1235.                 GBKFreq[62][116] = 564;

    1236. 

  1236.                 GBKFreq[67][135] = 563;

    1237. 

  1237.                 GBKFreq[5][86] = 562;

    1238. 

  1238.                 GBKFreq[72][186] = 561;

    1239. 

  1239.                 GBKFreq[75][161] = 560;

    1240. 

  1240.                 GBKFreq[78][130] = 559;

    1241. 

  1241.                 GBKFreq[94][30] = 558;

    1242. 

  1242.                 GBKFreq[84][72] = 557;

    1243. 

  1243.                 GBKFreq[1][67] = 556;

    1244. 

  1244.                 GBKFreq[75][172] = 555;

    1245. 

  1245.                 GBKFreq[74][185] = 554;

    1246. 

  1246.                 GBKFreq[53][160] = 553;

    1247. 

  1247.                 GBKFreq[123][14] = 552;

    1248. 

  1248.                 GBKFreq[79][97] = 551;

    1249. 

  1249.                 GBKFreq[85][110] = 550;

    1250. 

  1250.                 GBKFreq[78][171] = 549;

    1251. 

  1251.                 GBKFreq[52][131] = 548;

    1252. 

  1252.                 GBKFreq[56][100] = 547;

    1253. 

  1253.                 GBKFreq[50][182] = 546;

    1254. 

  1254.                 GBKFreq[94][64] = 545;

    1255. 

  1255.                 GBKFreq[106][74] = 544;

    1256. 

  1256.                 GBKFreq[11][102] = 543;

    1257. 

  1257.                 GBKFreq[53][124] = 542;

    1258. 

  1258.                 GBKFreq[24][3] = 541;

    1259. 

  1259.                 GBKFreq[86][148] = 540;

    1260. 

  1260.                 GBKFreq[53][184] = 539;

    1261. 

  1261.                 GBKFreq[86][147] = 538;

    1262. 

  1262.                 GBKFreq[96][161] = 537;

    1263. 

  1263.                 GBKFreq[82][77] = 536;

    1264. 

  1264.                 GBKFreq[59][146] = 535;

    1265. 

  1265.                 GBKFreq[84][126] = 534;

    1266. 

  1266.                 GBKFreq[79][132] = 533;

    1267. 

  1267.                 GBKFreq[85][123] = 532;

    1268. 

  1268.                 GBKFreq[71][101] = 531;

    1269. 

  1269.                 GBKFreq[85][106] = 530;

    1270. 

  1270.                 GBKFreq[6][184] = 529;

    1271. 

  1271.                 GBKFreq[57][156] = 528;

    1272. 

  1272.                 GBKFreq[75][104] = 527;

    1273. 

  1273.                 GBKFreq[50][137] = 526;

    1274. 

  1274.                 GBKFreq[79][133] = 525;

    1275. 

  1275.                 GBKFreq[76][108] = 524;

    1276. 

  1276.                 GBKFreq[57][142] = 523;

    1277. 

  1277.                 GBKFreq[84][130] = 522;

    1278. 

  1278.                 GBKFreq[52][128] = 521;

    1279. 

  1279.                 GBKFreq[47][44] = 520;

    1280. 

  1280.                 GBKFreq[52][152] = 519;

    1281. 

  1281.                 GBKFreq[54][104] = 518;

    1282. 

  1282.                 GBKFreq[30][47] = 517;

    1283. 

  1283.                 GBKFreq[71][123] = 516;

    1284. 

  1284.                 GBKFreq[52][107] = 515;

    1285. 

  1285.                 GBKFreq[45][84] = 514;

    1286. 

  1286.                 GBKFreq[107][118] = 513;

    1287. 

  1287.                 GBKFreq[5][161] = 512;

    1288. 

  1288.                 GBKFreq[48][126] = 511;

    1289. 

  1289.                 GBKFreq[67][170] = 510;

    1290. 

  1290.                 GBKFreq[43][6] = 509;

    1291. 

  1291.                 GBKFreq[70][112] = 508;

    1292. 

  1292.                 GBKFreq[86][174] = 507;

    1293. 

  1293.                 GBKFreq[84][166] = 506;

    1294. 

  1294.                 GBKFreq[79][130] = 505;

    1295. 

  1295.                 GBKFreq[57][141] = 504;

    1296. 

  1296.                 GBKFreq[81][178] = 503;

    1297. 

  1297.                 GBKFreq[56][187] = 502;

    1298. 

  1298.                 GBKFreq[81][162] = 501;

    1299. 

  1299.                 GBKFreq[53][104] = 500;

    1300. 

  1300.                 GBKFreq[123][35] = 499;

    1301. 

  1301.                 GBKFreq[70][169] = 498;

    1302. 

  1302.                 GBKFreq[69][164] = 497;

    1303. 

  1303.                 GBKFreq[109][61] = 496;

    1304. 

  1304.                 GBKFreq[73][130] = 495;

    1305. 

  1305.                 GBKFreq[62][134] = 494;

    1306. 

  1306.                 GBKFreq[54][125] = 493;

    1307. 

  1307.                 GBKFreq[79][105] = 492;

    1308. 

  1308.                 GBKFreq[70][165] = 491;

    1309. 

  1309.                 GBKFreq[71][189] = 490;

    1310. 

  1310.                 GBKFreq[23][147] = 489;

    1311. 

  1311.                 GBKFreq[51][139] = 488;

    1312. 

  1312.                 GBKFreq[47][137] = 487;

    1313. 

  1313.                 GBKFreq[77][123] = 486;

    1314. 

  1314.                 GBKFreq[86][183] = 485;

    1315. 

  1315.                 GBKFreq[63][173] = 484;

    1316. 

  1316.                 GBKFreq[79][144] = 483;

    1317. 

  1317.                 GBKFreq[84][159] = 482;

    1318. 

  1318.                 GBKFreq[60][91] = 481;

    1319. 

  1319.                 GBKFreq[66][187] = 480;

    1320. 

  1320.                 GBKFreq[73][114] = 479;

    1321. 

  1321.                 GBKFreq[85][56] = 478;

    1322. 

  1322.                 GBKFreq[71][149] = 477;

    1323. 

  1323.                 GBKFreq[84][189] = 476;

    1324. 

  1324.                 GBKFreq[104][31] = 475;

    1325. 

  1325.                 GBKFreq[83][82] = 474;

    1326. 

  1326.                 GBKFreq[68][35] = 473;

    1327. 

  1327.                 GBKFreq[11][77] = 472;

    1328. 

  1328.                 GBKFreq[15][155] = 471;

    1329. 

  1329.                 GBKFreq[83][153] = 470;

    1330. 

  1330.                 GBKFreq[71][1] = 469;

    1331. 

  1331.                 GBKFreq[53][190] = 468;

    1332. 

  1332.                 GBKFreq[50][135] = 467;

    1333. 

  1333.                 GBKFreq[3][147] = 466;

    1334. 

  1334.                 GBKFreq[48][136] = 465;

    1335. 

  1335.                 GBKFreq[66][166] = 464;

    1336. 

  1336.                 GBKFreq[55][159] = 463;

    1337. 

  1337.                 GBKFreq[82][150] = 462;

    1338. 

  1338.                 GBKFreq[58][178] = 461;

    1339. 

  1339.                 GBKFreq[64][102] = 460;

    1340. 

  1340.                 GBKFreq[16][106] = 459;

    1341. 

  1341.                 GBKFreq[68][110] = 458;

    1342. 

  1342.                 GBKFreq[54][14] = 457;

    1343. 

  1343.                 GBKFreq[60][140] = 456;

    1344. 

  1344.                 GBKFreq[91][71] = 455;

    1345. 

  1345.                 GBKFreq[54][150] = 454;

    1346. 

  1346.                 GBKFreq[78][177] = 453;

    1347. 

  1347.                 GBKFreq[78][117] = 452;

    1348. 

  1348.                 GBKFreq[104][12] = 451;

    1349. 

  1349.                 GBKFreq[73][150] = 450;

    1350. 

  1350.                 GBKFreq[51][142] = 449;

    1351. 

  1351.                 GBKFreq[81][145] = 448;

    1352. 

  1352.                 GBKFreq[66][183] = 447;

    1353. 

  1353.                 GBKFreq[51][178] = 446;

    1354. 

  1354.                 GBKFreq[75][107] = 445;

    1355. 

  1355.                 GBKFreq[65][119] = 444;

    1356. 

  1356.                 GBKFreq[69][176] = 443;

    1357. 

  1357.                 GBKFreq[59][122] = 442;

    1358. 

  1358.                 GBKFreq[78][160] = 441;

    1359. 

  1359.                 GBKFreq[85][183] = 440;

    1360. 

  1360.                 GBKFreq[105][16] = 439;

    1361. 

  1361.                 GBKFreq[73][110] = 438;

    1362. 

  1362.                 GBKFreq[104][39] = 437;

    1363. 

  1363.                 GBKFreq[119][16] = 436;

    1364. 

  1364.                 GBKFreq[76][162] = 435;

    1365. 

  1365.                 GBKFreq[67][152] = 434;

    1366. 

  1366.                 GBKFreq[82][24] = 433;

    1367. 

  1367.                 GBKFreq[73][121] = 432;

    1368. 

  1368.                 GBKFreq[83][83] = 431;

    1369. 

  1369.                 GBKFreq[82][145] = 430;

    1370. 

  1370.                 GBKFreq[49][133] = 429;

    1371. 

  1371.                 GBKFreq[94][13] = 428;

    1372. 

  1372.                 GBKFreq[58][139] = 427;

    1373. 

  1373.                 GBKFreq[74][189] = 426;

    1374. 

  1374.                 GBKFreq[66][177] = 425;

    1375. 

  1375.                 GBKFreq[85][184] = 424;

    1376. 

  1376. 

    1377. 

  1377.                 GBKFreq[55][183] = 423;

    1378. 

  1378.                 GBKFreq[71][107] = 422;

    1379. 

  1379.                 GBKFreq[11][98] = 421;

    1380. 

  1380.                 GBKFreq[72][153] = 420;

    1381. 

  1381.                 GBKFreq[2][137] = 419;

    1382. 

  1382.                 GBKFreq[59][147] = 418;

    1383. 

  1383.                 GBKFreq[58][152] = 417;

    1384. 

  1384.                 GBKFreq[55][144] = 416;

    1385. 

  1385.                 GBKFreq[73][125] = 415;

    1386. 

  1386.                 GBKFreq[52][154] = 414;

    1387. 

  1387.                 GBKFreq[70][178] = 413;

    1388. 

  1388.                 GBKFreq[79][148] = 412;

    1389. 

  1389.                 GBKFreq[63][143] = 411;

    1390. 

  1390.                 GBKFreq[50][140] = 410;

    1391. 

  1391.                 GBKFreq[47][145] = 409;

    1392. 

  1392.                 GBKFreq[48][123] = 408;

    1393. 

  1393.                 GBKFreq[56][107] = 407;

    1394. 

  1394.                 GBKFreq[84][83] = 406;

    1395. 

  1395.                 GBKFreq[59][112] = 405;

    1396. 

  1396.                 GBKFreq[124][72] = 404;

    1397. 

  1397.                 GBKFreq[79][99] = 403;

    1398. 

  1398.                 GBKFreq[3][37] = 402;

    1399. 

  1399.                 GBKFreq[114][55] = 401;

    1400. 

  1400.                 GBKFreq[85][152] = 400;

    1401. 

  1401.                 GBKFreq[60][47] = 399;

    1402. 

  1402.                 GBKFreq[65][96] = 398;

    1403. 

  1403.                 GBKFreq[74][110] = 397;

    1404. 

  1404.                 GBKFreq[86][182] = 396;

    1405. 

  1405.                 GBKFreq[50][99] = 395;

    1406. 

  1406.                 GBKFreq[67][186] = 394;

    1407. 

  1407.                 GBKFreq[81][74] = 393;

    1408. 

  1408.                 GBKFreq[80][37] = 392;

    1409. 

  1409.                 GBKFreq[21][60] = 391;

    1410. 

  1410.                 GBKFreq[110][12] = 390;

    1411. 

  1411.                 GBKFreq[60][162] = 389;

    1412. 

  1412.                 GBKFreq[29][115] = 388;

    1413. 

  1413.                 GBKFreq[83][130] = 387;

    1414. 

  1414.                 GBKFreq[52][136] = 386;

    1415. 

  1415.                 GBKFreq[63][114] = 385;

    1416. 

  1416.                 GBKFreq[49][127] = 384;

    1417. 

  1417.                 GBKFreq[83][109] = 383;

    1418. 

  1418.                 GBKFreq[66][128] = 382;

    1419. 

  1419.                 GBKFreq[78][136] = 381;

    1420. 

  1420.                 GBKFreq[81][180] = 380;

    1421. 

  1421.                 GBKFreq[76][104] = 379;

    1422. 

  1422.                 GBKFreq[56][156] = 378;

    1423. 

  1423.                 GBKFreq[61][23] = 377;

    1424. 

  1424.                 GBKFreq[4][30] = 376;

    1425. 

  1425.                 GBKFreq[69][154] = 375;

    1426. 

  1426.                 GBKFreq[100][37] = 374;

    1427. 

  1427.                 GBKFreq[54][177] = 373;

    1428. 

  1428.                 GBKFreq[23][119] = 372;

    1429. 

  1429.                 GBKFreq[71][171] = 371;

    1430. 

  1430.                 GBKFreq[84][146] = 370;

    1431. 

  1431.                 GBKFreq[20][184] = 369;

    1432. 

  1432.                 GBKFreq[86][76] = 368;

    1433. 

  1433.                 GBKFreq[74][132] = 367;

    1434. 

  1434.                 GBKFreq[47][97] = 366;

    1435. 

  1435.                 GBKFreq[82][137] = 365;

    1436. 

  1436.                 GBKFreq[94][56] = 364;

    1437. 

  1437.                 GBKFreq[92][30] = 363;

    1438. 

  1438.                 GBKFreq[19][117] = 362;

    1439. 

  1439.                 GBKFreq[48][173] = 361;

    1440. 

  1440.                 GBKFreq[2][136] = 360;

    1441. 

  1441.                 GBKFreq[7][182] = 359;

    1442. 

  1442.                 GBKFreq[74][188] = 358;

    1443. 

  1443.                 GBKFreq[14][132] = 357;

    1444. 

  1444.                 GBKFreq[62][172] = 356;

    1445. 

  1445.                 GBKFreq[25][39] = 355;

    1446. 

  1446.                 GBKFreq[85][129] = 354;

    1447. 

  1447.                 GBKFreq[64][98] = 353;

    1448. 

  1448.                 GBKFreq[67][127] = 352;

    1449. 

  1449.                 GBKFreq[72][167] = 351;

    1450. 

  1450.                 GBKFreq[57][143] = 350;

    1451. 

  1451.                 GBKFreq[76][187] = 349;

    1452. 

  1452.                 GBKFreq[83][181] = 348;

    1453. 

  1453.                 GBKFreq[84][10] = 347;

    1454. 

  1454.                 GBKFreq[55][166] = 346;

    1455. 

  1455.                 GBKFreq[55][188] = 345;

    1456. 

  1456.                 GBKFreq[13][151] = 344;

    1457. 

  1457.                 GBKFreq[62][124] = 343;

    1458. 

  1458.                 GBKFreq[53][136] = 342;

    1459. 

  1459.                 GBKFreq[106][57] = 341;

    1460. 

  1460.                 GBKFreq[47][166] = 340;

    1461. 

  1461.                 GBKFreq[109][30] = 339;

    1462. 

  1462.                 GBKFreq[78][114] = 338;

    1463. 

  1463.                 GBKFreq[83][19] = 337;

    1464. 

  1464.                 GBKFreq[56][162] = 336;

    1465. 

  1465.                 GBKFreq[60][177] = 335;

    1466. 

  1466.                 GBKFreq[88][9] = 334;

    1467. 

  1467.                 GBKFreq[74][163] = 333;

    1468. 

  1468.                 GBKFreq[52][156] = 332;

    1469. 

  1469.                 GBKFreq[71][180] = 331;

    1470. 

  1470.                 GBKFreq[60][57] = 330;

    1471. 

  1471.                 GBKFreq[72][173] = 329;

    1472. 

  1472.                 GBKFreq[82][91] = 328;

    1473. 

  1473.                 GBKFreq[51][186] = 327;

    1474. 

  1474.                 GBKFreq[75][86] = 326;

    1475. 

  1475.                 GBKFreq[75][78] = 325;

    1476. 

  1476.                 GBKFreq[76][170] = 324;

    1477. 

  1477.                 GBKFreq[60][147] = 323;

    1478. 

  1478.                 GBKFreq[82][75] = 322;

    1479. 

  1479.                 GBKFreq[80][148] = 321;

    1480. 

  1480.                 GBKFreq[86][150] = 320;

    1481. 

  1481.                 GBKFreq[13][95] = 319;

    1482. 

  1482.                 GBKFreq[0][11] = 318;

    1483. 

  1483.                 GBKFreq[84][190] = 317;

    1484. 

  1484.                 GBKFreq[76][166] = 316;

    1485. 

  1485.                 GBKFreq[14][72] = 315;

    1486. 

  1486.                 GBKFreq[67][144] = 314;

    1487. 

  1487.                 GBKFreq[84][44] = 313;

    1488. 

  1488.                 GBKFreq[72][125] = 312;

    1489. 

  1489.                 GBKFreq[66][127] = 311;

    1490. 

  1490.                 GBKFreq[60][25] = 310;

    1491. 

  1491.                 GBKFreq[70][146] = 309;

    1492. 

  1492.                 GBKFreq[79][135] = 308;

    1493. 

  1493.                 GBKFreq[54][135] = 307;

    1494. 

  1494.                 GBKFreq[60][104] = 306;

    1495. 

  1495.                 GBKFreq[55][132] = 305;

    1496. 

  1496.                 GBKFreq[94][2] = 304;

    1497. 

  1497.                 GBKFreq[54][133] = 303;

    1498. 

  1498.                 GBKFreq[56][190] = 302;

    1499. 

  1499.                 GBKFreq[58][174] = 301;

    1500. 

  1500.                 GBKFreq[80][144] = 300;

    1501. 

  1501.                 GBKFreq[85][113] = 299;

    1502. 

  1502. 

    1503. 

  1503.                 #endregion

    1504. 

  1504.             }

    1505. 

  1505. 

    1506. 

  1506.             if (Big5Freq[0] == null)

    1507. 

  1507.             {

    1508. 

  1508.                 for (i = 0; i < 94; i++)

    1509. 

  1509.                 {

    1510. 

  1510.                     Big5Freq[i] = new int[158];

    1511. 

  1511.                 }

    1512. 

  1512. 

    1513. 

  1513.                 #region Big5Freq[9][89] = 600;

    1514. 

  1514. 

    1515. 

  1515.                 Big5Freq[11][15] = 599;

    1516. 

  1516.                 Big5Freq[3][66] = 598;

    1517. 

  1517.                 Big5Freq[6][121] = 597;

    1518. 

  1518.                 Big5Freq[3][0] = 596;

    1519. 

  1519.                 Big5Freq[5][82] = 595;

    1520. 

  1520.                 Big5Freq[3][42] = 594;

    1521. 

  1521.                 Big5Freq[5][34] = 593;

    1522. 

  1522.                 Big5Freq[3][8] = 592;

    1523. 

  1523.                 Big5Freq[3][6] = 591;

    1524. 

  1524.                 Big5Freq[3][67] = 590;

    1525. 

  1525.                 Big5Freq[7][139] = 589;

    1526. 

  1526.                 Big5Freq[23][137] = 588;

    1527. 

  1527.                 Big5Freq[12][46] = 587;

    1528. 

  1528.                 Big5Freq[4][8] = 586;

    1529. 

  1529.                 Big5Freq[4][41] = 585;

    1530. 

  1530.                 Big5Freq[18][47] = 584;

    1531. 

  1531.                 Big5Freq[12][114] = 583;

    1532. 

  1532.                 Big5Freq[6][1] = 582;

    1533. 

  1533.                 Big5Freq[22][60] = 581;

    1534. 

  1534.                 Big5Freq[5][46] = 580;

    1535. 

  1535.                 Big5Freq[11][79] = 579;

    1536. 

  1536.                 Big5Freq[3][23] = 578;

    1537. 

  1537.                 Big5Freq[7][114] = 577;

    1538. 

  1538.                 Big5Freq[29][102] = 576;

    1539. 

  1539.                 Big5Freq[19][14] = 575;

    1540. 

  1540.                 Big5Freq[4][133] = 574;

    1541. 

  1541.                 Big5Freq[3][29] = 573;

    1542. 

  1542.                 Big5Freq[4][109] = 572;

    1543. 

  1543.                 Big5Freq[14][127] = 571;

    1544. 

  1544.                 Big5Freq[5][48] = 570;

    1545. 

  1545.                 Big5Freq[13][104] = 569;

    1546. 

  1546.                 Big5Freq[3][132] = 568;

    1547. 

  1547.                 Big5Freq[26][64] = 567;

    1548. 

  1548.                 Big5Freq[7][19] = 566;

    1549. 

  1549.                 Big5Freq[4][12] = 565;

    1550. 

  1550.                 Big5Freq[11][124] = 564;

    1551. 

  1551.                 Big5Freq[7][89] = 563;

    1552. 

  1552.                 Big5Freq[15][124] = 562;

    1553. 

  1553.                 Big5Freq[4][108] = 561;

    1554. 

  1554.                 Big5Freq[19][66] = 560;

    1555. 

  1555.                 Big5Freq[3][21] = 559;

    1556. 

  1556.                 Big5Freq[24][12] = 558;

    1557. 

  1557.                 Big5Freq[28][111] = 557;

    1558. 

  1558.                 Big5Freq[12][107] = 556;

    1559. 

  1559.                 Big5Freq[3][112] = 555;

    1560. 

  1560.                 Big5Freq[8][113] = 554;

    1561. 

  1561.                 Big5Freq[5][40] = 553;

    1562. 

  1562.                 Big5Freq[26][145] = 552;

    1563. 

  1563.                 Big5Freq[3][48] = 551;

    1564. 

  1564.                 Big5Freq[3][70] = 550;

    1565. 

  1565.                 Big5Freq[22][17] = 549;

    1566. 

  1566.                 Big5Freq[16][47] = 548;

    1567. 

  1567.                 Big5Freq[3][53] = 547;

    1568. 

  1568.                 Big5Freq[4][24] = 546;

    1569. 

  1569.                 Big5Freq[32][120] = 545;

    1570. 

  1570.                 Big5Freq[24][49] = 544;

    1571. 

  1571.                 Big5Freq[24][142] = 543;

    1572. 

  1572.                 Big5Freq[18][66] = 542;

    1573. 

  1573.                 Big5Freq[29][150] = 541;

    1574. 

  1574.                 Big5Freq[5][122] = 540;

    1575. 

  1575.                 Big5Freq[5][114] = 539;

    1576. 

  1576.                 Big5Freq[3][44] = 538;

    1577. 

  1577.                 Big5Freq[10][128] = 537;

    1578. 

  1578.                 Big5Freq[15][20] = 536;

    1579. 

  1579.                 Big5Freq[13][33] = 535;

    1580. 

  1580.                 Big5Freq[14][87] = 534;

    1581. 

  1581.                 Big5Freq[3][126] = 533;

    1582. 

  1582.                 Big5Freq[4][53] = 532;

    1583. 

  1583.                 Big5Freq[4][40] = 531;

    1584. 

  1584.                 Big5Freq[9][93] = 530;

    1585. 

  1585.                 Big5Freq[15][137] = 529;

    1586. 

  1586.                 Big5Freq[10][123] = 528;

    1587. 

  1587.                 Big5Freq[4][56] = 527;

    1588. 

  1588.                 Big5Freq[5][71] = 526;

    1589. 

  1589.                 Big5Freq[10][8] = 525;

    1590. 

  1590.                 Big5Freq[5][16] = 524;

    1591. 

  1591.                 Big5Freq[5][146] = 523;

    1592. 

  1592.                 Big5Freq[18][88] = 522;

    1593. 

  1593.                 Big5Freq[24][4] = 521;

    1594. 

  1594.                 Big5Freq[20][47] = 520;

    1595. 

  1595.                 Big5Freq[5][33] = 519;

    1596. 

  1596.                 Big5Freq[9][43] = 518;

    1597. 

  1597.                 Big5Freq[20][12] = 517;

    1598. 

  1598.                 Big5Freq[20][13] = 516;

    1599. 

  1599.                 Big5Freq[5][156] = 515;

    1600. 

  1600.                 Big5Freq[22][140] = 514;

    1601. 

  1601.                 Big5Freq[8][146] = 513;

    1602. 

  1602.                 Big5Freq[21][123] = 512;

    1603. 

  1603.                 Big5Freq[4][90] = 511;

    1604. 

  1604.                 Big5Freq[5][62] = 510;

    1605. 

  1605.                 Big5Freq[17][59] = 509;

    1606. 

  1606.                 Big5Freq[10][37] = 508;

    1607. 

  1607.                 Big5Freq[18][107] = 507;

    1608. 

  1608.                 Big5Freq[14][53] = 506;

    1609. 

  1609.                 Big5Freq[22][51] = 505;

    1610. 

  1610.                 Big5Freq[8][13] = 504;

    1611. 

  1611.                 Big5Freq[5][29] = 503;

    1612. 

  1612.                 Big5Freq[9][7] = 502;

    1613. 

  1613.                 Big5Freq[22][14] = 501;

    1614. 

  1614.                 Big5Freq[8][55] = 500;

    1615. 

  1615.                 Big5Freq[33][9] = 499;

    1616. 

  1616.                 Big5Freq[16][64] = 498;

    1617. 

  1617.                 Big5Freq[7][131] = 497;

    1618. 

  1618.                 Big5Freq[34][4] = 496;

    1619. 

  1619.                 Big5Freq[7][101] = 495;

    1620. 

  1620.                 Big5Freq[11][139] = 494;

    1621. 

  1621.                 Big5Freq[3][135] = 493;

    1622. 

  1622.                 Big5Freq[7][102] = 492;

    1623. 

  1623.                 Big5Freq[17][13] = 491;

    1624. 

  1624.                 Big5Freq[3][20] = 490;

    1625. 

  1625.                 Big5Freq[27][106] = 489;

    1626. 

  1626.                 Big5Freq[5][88] = 488;

    1627. 

  1627.                 Big5Freq[6][33] = 487;

    1628. 

  1628.                 Big5Freq[5][139] = 486;

    1629. 

  1629.                 Big5Freq[6][0] = 485;

    1630. 

  1630.                 Big5Freq[17][58] = 484;

    1631. 

  1631.                 Big5Freq[5][133] = 483;

    1632. 

  1632.                 Big5Freq[9][107] = 482;

    1633. 

  1633.                 Big5Freq[23][39] = 481;

    1634. 

  1634.                 Big5Freq[5][23] = 480;

    1635. 

  1635.                 Big5Freq[3][79] = 479;

    1636. 

  1636.                 Big5Freq[32][97] = 478;

    1637. 

  1637.                 Big5Freq[3][136] = 477;

    1638. 

  1638.                 Big5Freq[4][94] = 476;

    1639. 

  1639.                 Big5Freq[21][61] = 475;

    1640. 

  1640.                 Big5Freq[23][123] = 474;

    1641. 

  1641.                 Big5Freq[26][16] = 473;

    1642. 

  1642.                 Big5Freq[24][137] = 472;

    1643. 

  1643.                 Big5Freq[22][18] = 471;

    1644. 

  1644.                 Big5Freq[5][1] = 470;

    1645. 

  1645.                 Big5Freq[20][119] = 469;

    1646. 

  1646.                 Big5Freq[3][7] = 468;

    1647. 

  1647.                 Big5Freq[10][79] = 467;

    1648. 

  1648.                 Big5Freq[15][105] = 466;

    1649. 

  1649.                 Big5Freq[3][144] = 465;

    1650. 

  1650.                 Big5Freq[12][80] = 464;

    1651. 

  1651.                 Big5Freq[15][73] = 463;

    1652. 

  1652.                 Big5Freq[3][19] = 462;

    1653. 

  1653.                 Big5Freq[8][109] = 461;

    1654. 

  1654.                 Big5Freq[3][15] = 460;

    1655. 

  1655.                 Big5Freq[31][82] = 459;

    1656. 

  1656.                 Big5Freq[3][43] = 458;

    1657. 

  1657.                 Big5Freq[25][119] = 457;

    1658. 

  1658.                 Big5Freq[16][111] = 456;

    1659. 

  1659.                 Big5Freq[7][77] = 455;

    1660. 

  1660.                 Big5Freq[3][95] = 454;

    1661. 

  1661.                 Big5Freq[24][82] = 453;

    1662. 

  1662.                 Big5Freq[7][52] = 452;

    1663. 

  1663.                 Big5Freq[9][151] = 451;

    1664. 

  1664.                 Big5Freq[3][129] = 450;

    1665. 

  1665.                 Big5Freq[5][87] = 449;

    1666. 

  1666.                 Big5Freq[3][55] = 448;

    1667. 

  1667.                 Big5Freq[8][153] = 447;

    1668. 

  1668.                 Big5Freq[4][83] = 446;

    1669. 

  1669.                 Big5Freq[3][114] = 445;

    1670. 

  1670.                 Big5Freq[23][147] = 444;

    1671. 

  1671.                 Big5Freq[15][31] = 443;

    1672. 

  1672.                 Big5Freq[3][54] = 442;

    1673. 

  1673.                 Big5Freq[11][122] = 441;

    1674. 

  1674.                 Big5Freq[4][4] = 440;

    1675. 

  1675.                 Big5Freq[34][149] = 439;

    1676. 

  1676.                 Big5Freq[3][17] = 438;

    1677. 

  1677.                 Big5Freq[21][64] = 437;

    1678. 

  1678.                 Big5Freq[26][144] = 436;

    1679. 

  1679.                 Big5Freq[4][62] = 435;

    1680. 

  1680.                 Big5Freq[8][15] = 434;

    1681. 

  1681.                 Big5Freq[35][80] = 433;

    1682. 

  1682.                 Big5Freq[7][110] = 432;

    1683. 

  1683.                 Big5Freq[23][114] = 431;

    1684. 

  1684.                 Big5Freq[3][108] = 430;

    1685. 

  1685.                 Big5Freq[3][62] = 429;

    1686. 

  1686.                 Big5Freq[21][41] = 428;

    1687. 

  1687.                 Big5Freq[15][99] = 427;

    1688. 

  1688.                 Big5Freq[5][47] = 426;

    1689. 

  1689.                 Big5Freq[4][96] = 425;

    1690. 

  1690.                 Big5Freq[20][122] = 424;

    1691. 

  1691.                 Big5Freq[5][21] = 423;

    1692. 

  1692.                 Big5Freq[4][157] = 422;

    1693. 

  1693.                 Big5Freq[16][14] = 421;

    1694. 

  1694.                 Big5Freq[3][117] = 420;

    1695. 

  1695.                 Big5Freq[7][129] = 419;

    1696. 

  1696.                 Big5Freq[4][27] = 418;

    1697. 

  1697.                 Big5Freq[5][30] = 417;

    1698. 

  1698.                 Big5Freq[22][16] = 416;

    1699. 

  1699.                 Big5Freq[5][64] = 415;

    1700. 

  1700.                 Big5Freq[17][99] = 414;

    1701. 

  1701.                 Big5Freq[17][57] = 413;

    1702. 

  1702.                 Big5Freq[8][105] = 412;

    1703. 

  1703.                 Big5Freq[5][112] = 411;

    1704. 

  1704.                 Big5Freq[20][59] = 410;

    1705. 

  1705.                 Big5Freq[6][129] = 409;

    1706. 

  1706.                 Big5Freq[18][17] = 408;

    1707. 

  1707.                 Big5Freq[3][92] = 407;

    1708. 

  1708.                 Big5Freq[28][118] = 406;

    1709. 

  1709.                 Big5Freq[3][109] = 405;

    1710. 

  1710.                 Big5Freq[31][51] = 404;

    1711. 

  1711.                 Big5Freq[13][116] = 403;

    1712. 

  1712.                 Big5Freq[6][15] = 402;

    1713. 

  1713.                 Big5Freq[36][136] = 401;

    1714. 

  1714.                 Big5Freq[12][74] = 400;

    1715. 

  1715.                 Big5Freq[20][88] = 399;

    1716. 

  1716.                 Big5Freq[36][68] = 398;

    1717. 

  1717.                 Big5Freq[3][147] = 397;

    1718. 

  1718.                 Big5Freq[15][84] = 396;

    1719. 

  1719.                 Big5Freq[16][32] = 395;

    1720. 

  1720.                 Big5Freq[16][58] = 394;

    1721. 

  1721.                 Big5Freq[7][66] = 393;

    1722. 

  1722.                 Big5Freq[23][107] = 392;

    1723. 

  1723.                 Big5Freq[9][6] = 391;

    1724. 

  1724.                 Big5Freq[12][86] = 390;

    1725. 

  1725.                 Big5Freq[23][112] = 389;

    1726. 

  1726.                 Big5Freq[37][23] = 388;

    1727. 

  1727.                 Big5Freq[3][138] = 387;

    1728. 

  1728.                 Big5Freq[20][68] = 386;

    1729. 

  1729.                 Big5Freq[15][116] = 385;

    1730. 

  1730.                 Big5Freq[18][64] = 384;

    1731. 

  1731.                 Big5Freq[12][139] = 383;

    1732. 

  1732.                 Big5Freq[11][155] = 382;

    1733. 

  1733.                 Big5Freq[4][156] = 381;

    1734. 

  1734.                 Big5Freq[12][84] = 380;

    1735. 

  1735.                 Big5Freq[18][49] = 379;

    1736. 

  1736.                 Big5Freq[25][125] = 378;

    1737. 

  1737.                 Big5Freq[25][147] = 377;

    1738. 

  1738.                 Big5Freq[15][110] = 376;

    1739. 

  1739.                 Big5Freq[19][96] = 375;

    1740. 

  1740.                 Big5Freq[30][152] = 374;

    1741. 

  1741.                 Big5Freq[6][31] = 373;

    1742. 

  1742.                 Big5Freq[27][117] = 372;

    1743. 

  1743.                 Big5Freq[3][10] = 371;

    1744. 

  1744.                 Big5Freq[6][131] = 370;

    1745. 

  1745.                 Big5Freq[13][112] = 369;

    1746. 

  1746.                 Big5Freq[36][156] = 368;

    1747. 

  1747.                 Big5Freq[4][60] = 367;

    1748. 

  1748.                 Big5Freq[15][121] = 366;

    1749. 

  1749.                 Big5Freq[4][112] = 365;

    1750. 

  1750.                 Big5Freq[30][142] = 364;

    1751. 

  1751.                 Big5Freq[23][154] = 363;

    1752. 

  1752.                 Big5Freq[27][101] = 362;

    1753. 

  1753.                 Big5Freq[9][140] = 361;

    1754. 

  1754.                 Big5Freq[3][89] = 360;

    1755. 

  1755.                 Big5Freq[18][148] = 359;

    1756. 

  1756.                 Big5Freq[4][69] = 358;

    1757. 

  1757.                 Big5Freq[16][49] = 357;

    1758. 

  1758.                 Big5Freq[6][117] = 356;

    1759. 

  1759.                 Big5Freq[36][55] = 355;

    1760. 

  1760.                 Big5Freq[5][123] = 354;

    1761. 

  1761.                 Big5Freq[4][126] = 353;

    1762. 

  1762.                 Big5Freq[4][119] = 352;

    1763. 

  1763.                 Big5Freq[9][95] = 351;

    1764. 

  1764.                 Big5Freq[5][24] = 350;

    1765. 

  1765.                 Big5Freq[16][133] = 349;

    1766. 

  1766.                 Big5Freq[10][134] = 348;

    1767. 

  1767.                 Big5Freq[26][59] = 347;

    1768. 

  1768.                 Big5Freq[6][41] = 346;

    1769. 

  1769.                 Big5Freq[6][146] = 345;

    1770. 

  1770.                 Big5Freq[19][24] = 344;

    1771. 

  1771.                 Big5Freq[5][113] = 343;

    1772. 

  1772.                 Big5Freq[10][118] = 342;

    1773. 

  1773.                 Big5Freq[34][151] = 341;

    1774. 

  1774.                 Big5Freq[9][72] = 340;

    1775. 

  1775.                 Big5Freq[31][25] = 339;

    1776. 

  1776.                 Big5Freq[18][126] = 338;

    1777. 

  1777.                 Big5Freq[18][28] = 337;

    1778. 

  1778.                 Big5Freq[4][153] = 336;

    1779. 

  1779.                 Big5Freq[3][84] = 335;

    1780. 

  1780.                 Big5Freq[21][18] = 334;

    1781. 

  1781.                 Big5Freq[25][129] = 333;

    1782. 

  1782.                 Big5Freq[6][107] = 332;

    1783. 

  1783.                 Big5Freq[12][25] = 331;

    1784. 

  1784.                 Big5Freq[17][109] = 330;

    1785. 

  1785.                 Big5Freq[7][76] = 329;

    1786. 

  1786.                 Big5Freq[15][15] = 328;

    1787. 

  1787.                 Big5Freq[4][14] = 327;

    1788. 

  1788.                 Big5Freq[23][88] = 326;

    1789. 

  1789.                 Big5Freq[18][2] = 325;

    1790. 

  1790.                 Big5Freq[6][88] = 324;

    1791. 

  1791.                 Big5Freq[16][84] = 323;

    1792. 

  1792.                 Big5Freq[12][48] = 322;

    1793. 

  1793.                 Big5Freq[7][68] = 321;

    1794. 

  1794.                 Big5Freq[5][50] = 320;

    1795. 

  1795.                 Big5Freq[13][54] = 319;

    1796. 

  1796.                 Big5Freq[7][98] = 318;

    1797. 

  1797.                 Big5Freq[11][6] = 317;

    1798. 

  1798.                 Big5Freq[9][80] = 316;

    1799. 

  1799.                 Big5Freq[16][41] = 315;

    1800. 

  1800.                 Big5Freq[7][43] = 314;

    1801. 

  1801.                 Big5Freq[28][117] = 313;

    1802. 

  1802.                 Big5Freq[3][51] = 312;

    1803. 

  1803.                 Big5Freq[7][3] = 311;

    1804. 

  1804.                 Big5Freq[20][81] = 310;

    1805. 

  1805.                 Big5Freq[4][2] = 309;

    1806. 

  1806.                 Big5Freq[11][16] = 308;

    1807. 

  1807.                 Big5Freq[10][4] = 307;

    1808. 

  1808.                 Big5Freq[10][119] = 306;

    1809. 

  1809.                 Big5Freq[6][142] = 305;

    1810. 

  1810.                 Big5Freq[18][51] = 304;

    1811. 

  1811.                 Big5Freq[8][144] = 303;

    1812. 

  1812.                 Big5Freq[10][65] = 302;

    1813. 

  1813.                 Big5Freq[11][64] = 301;

    1814. 

  1814.                 Big5Freq[11][130] = 300;

    1815. 

  1815.                 Big5Freq[9][92] = 299;

    1816. 

  1816.                 Big5Freq[18][29] = 298;

    1817. 

  1817.                 Big5Freq[18][78] = 297;

    1818. 

  1818.                 Big5Freq[18][151] = 296;

    1819. 

  1819.                 Big5Freq[33][127] = 295;

    1820. 

  1820.                 Big5Freq[35][113] = 294;

    1821. 

  1821.                 Big5Freq[10][155] = 293;

    1822. 

  1822.                 Big5Freq[3][76] = 292;

    1823. 

  1823.                 Big5Freq[36][123] = 291;

    1824. 

  1824.                 Big5Freq[13][143] = 290;

    1825. 

  1825.                 Big5Freq[5][135] = 289;

    1826. 

  1826.                 Big5Freq[23][116] = 288;

    1827. 

  1827.                 Big5Freq[6][101] = 287;

    1828. 

  1828.                 Big5Freq[14][74] = 286;

    1829. 

  1829.                 Big5Freq[7][153] = 285;

    1830. 

  1830.                 Big5Freq[3][101] = 284;

    1831. 

  1831.                 Big5Freq[9][74] = 283;

    1832. 

  1832.                 Big5Freq[3][156] = 282;

    1833. 

  1833.                 Big5Freq[4][147] = 281;

    1834. 

  1834.                 Big5Freq[9][12] = 280;

    1835. 

  1835.                 Big5Freq[18][133] = 279;

    1836. 

  1836.                 Big5Freq[4][0] = 278;

    1837. 

  1837.                 Big5Freq[7][155] = 277;

    1838. 

  1838.                 Big5Freq[9][144] = 276;

    1839. 

  1839.                 Big5Freq[23][49] = 275;

    1840. 

  1840.                 Big5Freq[5][89] = 274;

    1841. 

  1841.                 Big5Freq[10][11] = 273;

    1842. 

  1842.                 Big5Freq[3][110] = 272;

    1843. 

  1843.                 Big5Freq[3][40] = 271;

    1844. 

  1844.                 Big5Freq[29][115] = 270;

    1845. 

  1845.                 Big5Freq[9][100] = 269;

    1846. 

  1846.                 Big5Freq[21][67] = 268;

    1847. 

  1847.                 Big5Freq[23][145] = 267;

    1848. 

  1848.                 Big5Freq[10][47] = 266;

    1849. 

  1849.                 Big5Freq[4][31] = 265;

    1850. 

  1850.                 Big5Freq[4][81] = 264;

    1851. 

  1851.                 Big5Freq[22][62] = 263;

    1852. 

  1852.                 Big5Freq[4][28] = 262;

    1853. 

  1853.                 Big5Freq[27][39] = 261;

    1854. 

  1854.                 Big5Freq[27][54] = 260;

    1855. 

  1855.                 Big5Freq[32][46] = 259;

    1856. 

  1856.                 Big5Freq[4][76] = 258;

    1857. 

  1857.                 Big5Freq[26][15] = 257;

    1858. 

  1858.                 Big5Freq[12][154] = 256;

    1859. 

  1859.                 Big5Freq[9][150] = 255;

    1860. 

  1860.                 Big5Freq[15][17] = 254;

    1861. 

  1861.                 Big5Freq[5][129] = 253;

    1862. 

  1862.                 Big5Freq[10][40] = 252;

    1863. 

  1863.                 Big5Freq[13][37] = 251;

    1864. 

  1864.                 Big5Freq[31][104] = 250;

    1865. 

  1865.                 Big5Freq[3][152] = 249;

    1866. 

  1866.                 Big5Freq[5][22] = 248;

    1867. 

  1867.                 Big5Freq[8][48] = 247;

    1868. 

  1868.                 Big5Freq[4][74] = 246;

    1869. 

  1869.                 Big5Freq[6][17] = 245;

    1870. 

  1870.                 Big5Freq[30][82] = 244;

    1871. 

  1871.                 Big5Freq[4][116] = 243;

    1872. 

  1872.                 Big5Freq[16][42] = 242;

    1873. 

  1873.                 Big5Freq[5][55] = 241;

    1874. 

  1874.                 Big5Freq[4][64] = 240;

    1875. 

  1875.                 Big5Freq[14][19] = 239;

    1876. 

  1876.                 Big5Freq[35][82] = 238;

    1877. 

  1877.                 Big5Freq[30][139] = 237;

    1878. 

  1878.                 Big5Freq[26][152] = 236;

    1879. 

  1879.                 Big5Freq[32][32] = 235;

    1880. 

  1880.                 Big5Freq[21][102] = 234;

    1881. 

  1881.                 Big5Freq[10][131] = 233;

    1882. 

  1882.                 Big5Freq[9][128] = 232;

    1883. 

  1883.                 Big5Freq[3][87] = 231;

    1884. 

  1884.                 Big5Freq[4][51] = 230;

    1885. 

  1885.                 Big5Freq[10][15] = 229;

    1886. 

  1886.                 Big5Freq[4][150] = 228;

    1887. 

  1887.                 Big5Freq[7][4] = 227;

    1888. 

  1888.                 Big5Freq[7][51] = 226;

    1889. 

  1889.                 Big5Freq[7][157] = 225;

    1890. 

  1890.                 Big5Freq[4][146] = 224;

    1891. 

  1891.                 Big5Freq[4][91] = 223;

    1892. 

  1892.                 Big5Freq[7][13] = 222;

    1893. 

  1893.                 Big5Freq[17][116] = 221;

    1894. 

  1894.                 Big5Freq[23][21] = 220;

    1895. 

  1895.                 Big5Freq[5][106] = 219;

    1896. 

  1896.                 Big5Freq[14][100] = 218;

    1897. 

  1897.                 Big5Freq[10][152] = 217;

    1898. 

  1898.                 Big5Freq[14][89] = 216;

    1899. 

  1899.                 Big5Freq[6][138] = 215;

    1900. 

  1900.                 Big5Freq[12][157] = 214;

    1901. 

  1901.                 Big5Freq[10][102] = 213;

    1902. 

  1902.                 Big5Freq[19][94] = 212;

    1903. 

  1903.                 Big5Freq[7][74] = 211;

    1904. 

  1904.                 Big5Freq[18][128] = 210;

    1905. 

  1905.                 Big5Freq[27][111] = 209;

    1906. 

  1906.                 Big5Freq[11][57] = 208;

    1907. 

  1907.                 Big5Freq[3][131] = 207;

    1908. 

  1908.                 Big5Freq[30][23] = 206;

    1909. 

  1909.                 Big5Freq[30][126] = 205;

    1910. 

  1910.                 Big5Freq[4][36] = 204;

    1911. 

  1911.                 Big5Freq[26][124] = 203;

    1912. 

  1912.                 Big5Freq[4][19] = 202;

    1913. 

  1913.                 Big5Freq[9][152] = 201;

    1914. 

  1914. 

    1915. 

  1915.                 #endregion

    1916. 

  1916.             }

    1917. 

  1917. 

    1918. 

  1918.             if (EUC_TWFreq[0] == null)

    1919. 

  1919.             {

    1920. 

  1920.                 for (i = 0; i < 94; i++)

    1921. 

  1921.                 {

    1922. 

  1922.                     EUC_TWFreq[i] = new int[94];

    1923. 

  1923.                 }

    1924. 

  1924. 

    1925. 

  1925.                 #region EUC_TWFreq[48][49] = 599;

    1926. 

  1926. 

    1927. 

  1927.                 EUC_TWFreq[35][65] = 598;

    1928. 

  1928.                 EUC_TWFreq[41][27] = 597;

    1929. 

  1929.                 EUC_TWFreq[35][0] = 596;

    1930. 

  1930.                 EUC_TWFreq[39][19] = 595;

    1931. 

  1931.                 EUC_TWFreq[35][42] = 594;

    1932. 

  1932.                 EUC_TWFreq[38][66] = 593;

    1933. 

  1933.                 EUC_TWFreq[35][8] = 592;

    1934. 

  1934.                 EUC_TWFreq[35][6] = 591;

    1935. 

  1935.                 EUC_TWFreq[35][66] = 590;

    1936. 

  1936.                 EUC_TWFreq[43][14] = 589;

    1937. 

  1937.                 EUC_TWFreq[69][80] = 588;

    1938. 

  1938.                 EUC_TWFreq[50][48] = 587;

    1939. 

  1939.                 EUC_TWFreq[36][71] = 586;

    1940. 

  1940.                 EUC_TWFreq[37][10] = 585;

    1941. 

  1941.                 EUC_TWFreq[60][52] = 584;

    1942. 

  1942.                 EUC_TWFreq[51][21] = 583;

    1943. 

  1943.                 EUC_TWFreq[40][2] = 582;

    1944. 

  1944.                 EUC_TWFreq[67][35] = 581;

    1945. 

  1945.                 EUC_TWFreq[38][78] = 580;

    1946. 

  1946.                 EUC_TWFreq[49][18] = 579;

    1947. 

  1947.                 EUC_TWFreq[35][23] = 578;

    1948. 

  1948.                 EUC_TWFreq[42][83] = 577;

    1949. 

  1949.                 EUC_TWFreq[79][47] = 576;

    1950. 

  1950.                 EUC_TWFreq[61][82] = 575;

    1951. 

  1951.                 EUC_TWFreq[38][7] = 574;

    1952. 

  1952.                 EUC_TWFreq[35][29] = 573;

    1953. 

  1953.                 EUC_TWFreq[37][77] = 572;

    1954. 

  1954.                 EUC_TWFreq[54][67] = 571;

    1955. 

  1955.                 EUC_TWFreq[38][80] = 570;

    1956. 

  1956.                 EUC_TWFreq[52][74] = 569;

    1957. 

  1957.                 EUC_TWFreq[36][37] = 568;

    1958. 

  1958.                 EUC_TWFreq[74][8] = 567;

    1959. 

  1959.                 EUC_TWFreq[41][83] = 566;

    1960. 

  1960.                 EUC_TWFreq[36][75] = 565;

    1961. 

  1961.                 EUC_TWFreq[49][63] = 564;

    1962. 

  1962.                 EUC_TWFreq[42][58] = 563;

    1963. 

  1963.                 EUC_TWFreq[56][33] = 562;

    1964. 

  1964.                 EUC_TWFreq[37][76] = 561;

    1965. 

  1965.                 EUC_TWFreq[62][39] = 560;

    1966. 

  1966.                 EUC_TWFreq[35][21] = 559;

    1967. 

  1967.                 EUC_TWFreq[70][19] = 558;

    1968. 

  1968.                 EUC_TWFreq[77][88] = 557;

    1969. 

  1969.                 EUC_TWFreq[51][14] = 556;

    1970. 

  1970.                 EUC_TWFreq[36][17] = 555;

    1971. 

  1971.                 EUC_TWFreq[44][51] = 554;

    1972. 

  1972.                 EUC_TWFreq[38][72] = 553;

    1973. 

  1973.                 EUC_TWFreq[74][90] = 552;

    1974. 

  1974.                 EUC_TWFreq[35][48] = 551;

    1975. 

  1975.                 EUC_TWFreq[35][69] = 550;

    1976. 

  1976.                 EUC_TWFreq[66][86] = 549;

    1977. 

  1977.                 EUC_TWFreq[57][20] = 548;

    1978. 

  1978.                 EUC_TWFreq[35][53] = 547;

    1979. 

  1979.                 EUC_TWFreq[36][87] = 546;

    1980. 

  1980.                 EUC_TWFreq[84][67] = 545;

    1981. 

  1981.                 EUC_TWFreq[70][56] = 544;

    1982. 

  1982.                 EUC_TWFreq[71][54] = 543;

    1983. 

  1983.                 EUC_TWFreq[60][70] = 542;

    1984. 

  1984.                 EUC_TWFreq[80][1] = 541;

    1985. 

  1985.                 EUC_TWFreq[39][59] = 540;

    1986. 

  1986.                 EUC_TWFreq[39][51] = 539;

    1987. 

  1987.                 EUC_TWFreq[35][44] = 538;

    1988. 

  1988.                 EUC_TWFreq[48][4] = 537;

    1989. 

  1989.                 EUC_TWFreq[55][24] = 536;

    1990. 

  1990.                 EUC_TWFreq[52][4] = 535;

    1991. 

  1991.                 EUC_TWFreq[54][26] = 534;

    1992. 

  1992.                 EUC_TWFreq[36][31] = 533;

    1993. 

  1993.                 EUC_TWFreq[37][22] = 532;

    1994. 

  1994.                 EUC_TWFreq[37][9] = 531;

    1995. 

  1995.                 EUC_TWFreq[46][0] = 530;

    1996. 

  1996.                 EUC_TWFreq[56][46] = 529;

    1997. 

  1997.                 EUC_TWFreq[47][93] = 528;

    1998. 

  1998.                 EUC_TWFreq[37][25] = 527;

    1999. 

  1999.                 EUC_TWFreq[39][8] = 526;

    2000. 

  2000.                 EUC_TWFreq[46][73] = 525;

    2001. 

  2001.                 EUC_TWFreq[38][48] = 524;

    2002. 

  2002.                 EUC_TWFreq[39][83] = 523;

    2003. 

  2003.                 EUC_TWFreq[60][92] = 522;

    2004. 

  2004.                 EUC_TWFreq[70][11] = 521;

    2005. 

  2005.                 EUC_TWFreq[63][84] = 520;

    2006. 

  2006.                 EUC_TWFreq[38][65] = 519;

    2007. 

  2007.                 EUC_TWFreq[45][45] = 518;

    2008. 

  2008.                 EUC_TWFreq[63][49] = 517;

    2009. 

  2009.                 EUC_TWFreq[63][50] = 516;

    2010. 

  2010.                 EUC_TWFreq[39][93] = 515;

    2011. 

  2011.                 EUC_TWFreq[68][20] = 514;

    2012. 

  2012.                 EUC_TWFreq[44][84] = 513;

    2013. 

  2013.                 EUC_TWFreq[66][34] = 512;

    2014. 

  2014.                 EUC_TWFreq[37][58] = 511;

    2015. 

  2015.                 EUC_TWFreq[39][0] = 510;

    2016. 

  2016.                 EUC_TWFreq[59][1] = 509;

    2017. 

  2017.                 EUC_TWFreq[47][8] = 508;

    2018. 

  2018.                 EUC_TWFreq[61][17] = 507;

    2019. 

  2019.                 EUC_TWFreq[53][87] = 506;

    2020. 

  2020.                 EUC_TWFreq[67][26] = 505;

    2021. 

  2021.                 EUC_TWFreq[43][46] = 504;

    2022. 

  2022.                 EUC_TWFreq[38][61] = 503;

    2023. 

  2023.                 EUC_TWFreq[45][9] = 502;

    2024. 

  2024.                 EUC_TWFreq[66][83] = 501;

    2025. 

  2025.                 EUC_TWFreq[43][88] = 500;

    2026. 

  2026.                 EUC_TWFreq[85][20] = 499;

    2027. 

  2027.                 EUC_TWFreq[57][36] = 498;

    2028. 

  2028.                 EUC_TWFreq[43][6] = 497;

    2029. 

  2029.                 EUC_TWFreq[86][77] = 496;

    2030. 

  2030.                 EUC_TWFreq[42][70] = 495;

    2031. 

  2031.                 EUC_TWFreq[49][78] = 494;

    2032. 

  2032.                 EUC_TWFreq[36][40] = 493;

    2033. 

  2033.                 EUC_TWFreq[42][71] = 492;

    2034. 

  2034.                 EUC_TWFreq[58][49] = 491;

    2035. 

  2035.                 EUC_TWFreq[35][20] = 490;

    2036. 

  2036.                 EUC_TWFreq[76][20] = 489;

    2037. 

  2037.                 EUC_TWFreq[39][25] = 488;

    2038. 

  2038.                 EUC_TWFreq[40][34] = 487;

    2039. 

  2039.                 EUC_TWFreq[39][76] = 486;

    2040. 

  2040.                 EUC_TWFreq[40][1] = 485;

    2041. 

  2041.                 EUC_TWFreq[59][0] = 484;

    2042. 

  2042.                 EUC_TWFreq[39][70] = 483;

    2043. 

  2043.                 EUC_TWFreq[46][14] = 482;

    2044. 

  2044.                 EUC_TWFreq[68][77] = 481;

    2045. 

  2045.                 EUC_TWFreq[38][55] = 480;

    2046. 

  2046.                 EUC_TWFreq[35][78] = 479;

    2047. 

  2047.                 EUC_TWFreq[84][44] = 478;

    2048. 

  2048.                 EUC_TWFreq[36][41] = 477;

    2049. 

  2049.                 EUC_TWFreq[37][62] = 476;

    2050. 

  2050.                 EUC_TWFreq[65][67] = 475;

    2051. 

  2051.                 EUC_TWFreq[69][66] = 474;

    2052. 

  2052.                 EUC_TWFreq[73][55] = 473;

    2053. 

  2053.                 EUC_TWFreq[71][49] = 472;

    2054. 

  2054.                 EUC_TWFreq[66][87] = 471;

    2055. 

  2055.                 EUC_TWFreq[38][33] = 470;

    2056. 

  2056.                 EUC_TWFreq[64][61] = 469;

    2057. 

  2057.                 EUC_TWFreq[35][7] = 468;

    2058. 

  2058.                 EUC_TWFreq[47][49] = 467;

    2059. 

  2059.                 EUC_TWFreq[56][14] = 466;

    2060. 

  2060.                 EUC_TWFreq[36][49] = 465;

    2061. 

  2061.                 EUC_TWFreq[50][81] = 464;

    2062. 

  2062.                 EUC_TWFreq[55][76] = 463;

    2063. 

  2063.                 EUC_TWFreq[35][19] = 462;

    2064. 

  2064.                 EUC_TWFreq[44][47] = 461;

    2065. 

  2065.                 EUC_TWFreq[35][15] = 460;

    2066. 

  2066.                 EUC_TWFreq[82][59] = 459;

    2067. 

  2067.                 EUC_TWFreq[35][43] = 458;

    2068. 

  2068.                 EUC_TWFreq[73][0] = 457;

    2069. 

  2069.                 EUC_TWFreq[57][83] = 456;

    2070. 

  2070.                 EUC_TWFreq[42][46] = 455;

    2071. 

  2071.                 EUC_TWFreq[36][0] = 454;

    2072. 

  2072.                 EUC_TWFreq[70][88] = 453;

    2073. 

  2073.                 EUC_TWFreq[42][22] = 452;

    2074. 

  2074.                 EUC_TWFreq[46][58] = 451;

    2075. 

  2075.                 EUC_TWFreq[36][34] = 450;

    2076. 

  2076.                 EUC_TWFreq[39][24] = 449;

    2077. 

  2077.                 EUC_TWFreq[35][55] = 448;

    2078. 

  2078.                 EUC_TWFreq[44][91] = 447;

    2079. 

  2079.                 EUC_TWFreq[37][51] = 446;

    2080. 

  2080.                 EUC_TWFreq[36][19] = 445;

    2081. 

  2081.                 EUC_TWFreq[69][90] = 444;

    2082. 

  2082.                 EUC_TWFreq[55][35] = 443;

    2083. 

  2083.                 EUC_TWFreq[35][54] = 442;

    2084. 

  2084.                 EUC_TWFreq[49][61] = 441;

    2085. 

  2085.                 EUC_TWFreq[36][67] = 440;

    2086. 

  2086.                 EUC_TWFreq[88][34] = 439;

    2087. 

  2087.                 EUC_TWFreq[35][17] = 438;

    2088. 

  2088.                 EUC_TWFreq[65][69] = 437;

    2089. 

  2089.                 EUC_TWFreq[74][89] = 436;

    2090. 

  2090.                 EUC_TWFreq[37][31] = 435;

    2091. 

  2091.                 EUC_TWFreq[43][48] = 434;

    2092. 

  2092.                 EUC_TWFreq[89][27] = 433;

    2093. 

  2093.                 EUC_TWFreq[42][79] = 432;

    2094. 

  2094.                 EUC_TWFreq[69][57] = 431;

    2095. 

  2095.                 EUC_TWFreq[36][13] = 430;

    2096. 

  2096.                 EUC_TWFreq[35][62] = 429;

    2097. 

  2097.                 EUC_TWFreq[65][47] = 428;

    2098. 

  2098.                 EUC_TWFreq[56][8] = 427;

    2099. 

  2099.                 EUC_TWFreq[38][79] = 426;

    2100. 

  2100.                 EUC_TWFreq[37][64] = 425;

    2101. 

  2101.                 EUC_TWFreq[64][64] = 424;

    2102. 

  2102.                 EUC_TWFreq[38][53] = 423;

    2103. 

  2103.                 EUC_TWFreq[38][31] = 422;

    2104. 

  2104.                 EUC_TWFreq[56][81] = 421;

    2105. 

  2105.                 EUC_TWFreq[36][22] = 420;

    2106. 

  2106.                 EUC_TWFreq[43][4] = 419;

    2107. 

  2107.                 EUC_TWFreq[36][90] = 418;

    2108. 

  2108.                 EUC_TWFreq[38][62] = 417;

    2109. 

  2109.                 EUC_TWFreq[66][85] = 416;

    2110. 

  2110.                 EUC_TWFreq[39][1] = 415;

    2111. 

  2111.                 EUC_TWFreq[59][40] = 414;

    2112. 

  2112.                 EUC_TWFreq[58][93] = 413;

    2113. 

  2113.                 EUC_TWFreq[44][43] = 412;

    2114. 

  2114.                 EUC_TWFreq[39][49] = 411;

    2115. 

  2115.                 EUC_TWFreq[64][2] = 410;

    2116. 

  2116.                 EUC_TWFreq[41][35] = 409;

    2117. 

  2117.                 EUC_TWFreq[60][22] = 408;

    2118. 

  2118.                 EUC_TWFreq[35][91] = 407;

    2119. 

  2119.                 EUC_TWFreq[78][1] = 406;

    2120. 

  2120.                 EUC_TWFreq[36][14] = 405;

    2121. 

  2121.                 EUC_TWFreq[82][29] = 404;

    2122. 

  2122.                 EUC_TWFreq[52][86] = 403;

    2123. 

  2123.                 EUC_TWFreq[40][16] = 402;

    2124. 

  2124.                 EUC_TWFreq[91][52] = 401;

    2125. 

  2125.                 EUC_TWFreq[50][75] = 400;

    2126. 

  2126.                 EUC_TWFreq[64][30] = 399;

    2127. 

  2127.                 EUC_TWFreq[90][78] = 398;

    2128. 

  2128.                 EUC_TWFreq[36][52] = 397;

    2129. 

  2129.                 EUC_TWFreq[55][87] = 396;

    2130. 

  2130.                 EUC_TWFreq[57][5] = 395;

    2131. 

  2131.                 EUC_TWFreq[57][31] = 394;

    2132. 

  2132.                 EUC_TWFreq[42][35] = 393;

    2133. 

  2133.                 EUC_TWFreq[69][50] = 392;

    2134. 

  2134.                 EUC_TWFreq[45][8] = 391;

    2135. 

  2135.                 EUC_TWFreq[50][87] = 390;

    2136. 

  2136.                 EUC_TWFreq[69][55] = 389;

    2137. 

  2137.                 EUC_TWFreq[92][3] = 388;

    2138. 

  2138.                 EUC_TWFreq[36][43] = 387;

    2139. 

  2139.                 EUC_TWFreq[64][10] = 386;

    2140. 

  2140.                 EUC_TWFreq[56][25] = 385;

    2141. 

  2141.                 EUC_TWFreq[60][68] = 384;

    2142. 

  2142.                 EUC_TWFreq[51][46] = 383;

    2143. 

  2143.                 EUC_TWFreq[50][0] = 382;

    2144. 

  2144.                 EUC_TWFreq[38][30] = 381;

    2145. 

  2145.                 EUC_TWFreq[50][85] = 380;

    2146. 

  2146.                 EUC_TWFreq[60][54] = 379;

    2147. 

  2147.                 EUC_TWFreq[73][6] = 378;

    2148. 

  2148.                 EUC_TWFreq[73][28] = 377;

    2149. 

  2149.                 EUC_TWFreq[56][19] = 376;

    2150. 

  2150.                 EUC_TWFreq[62][69] = 375;

    2151. 

  2151.                 EUC_TWFreq[81][66] = 374;

    2152. 

  2152.                 EUC_TWFreq[40][32] = 373;

    2153. 

  2153.                 EUC_TWFreq[76][31] = 372;

    2154. 

  2154.                 EUC_TWFreq[35][10] = 371;

    2155. 

  2155.                 EUC_TWFreq[41][37] = 370;

    2156. 

  2156.                 EUC_TWFreq[52][82] = 369;

    2157. 

  2157.                 EUC_TWFreq[91][72] = 368;

    2158. 

  2158.                 EUC_TWFreq[37][29] = 367;

    2159. 

  2159.                 EUC_TWFreq[56][30] = 366;

    2160. 

  2160.                 EUC_TWFreq[37][80] = 365;

    2161. 

  2161.                 EUC_TWFreq[81][56] = 364;

    2162. 

  2162.                 EUC_TWFreq[70][3] = 363;

    2163. 

  2163.                 EUC_TWFreq[76][15] = 362;

    2164. 

  2164.                 EUC_TWFreq[46][47] = 361;

    2165. 

  2165.                 EUC_TWFreq[35][88] = 360;

    2166. 

  2166.                 EUC_TWFreq[61][58] = 359;

    2167. 

  2167.                 EUC_TWFreq[37][37] = 358;

    2168. 

  2168.                 EUC_TWFreq[57][22] = 357;

    2169. 

  2169.                 EUC_TWFreq[41][23] = 356;

    2170. 

  2170.                 EUC_TWFreq[90][66] = 355;

    2171. 

  2171.                 EUC_TWFreq[39][60] = 354;

    2172. 

  2172.                 EUC_TWFreq[38][0] = 353;

    2173. 

  2173.                 EUC_TWFreq[37][87] = 352;

    2174. 

  2174.                 EUC_TWFreq[46][2] = 351;

    2175. 

  2175.                 EUC_TWFreq[38][56] = 350;

    2176. 

  2176.                 EUC_TWFreq[58][11] = 349;

    2177. 

  2177.                 EUC_TWFreq[48][10] = 348;

    2178. 

  2178.                 EUC_TWFreq[74][4] = 347;

    2179. 

  2179.                 EUC_TWFreq[40][42] = 346;

    2180. 

  2180.                 EUC_TWFreq[41][52] = 345;

    2181. 

  2181.                 EUC_TWFreq[61][92] = 344;

    2182. 

  2182.                 EUC_TWFreq[39][50] = 343;

    2183. 

  2183.                 EUC_TWFreq[47][88] = 342;

    2184. 

  2184.                 EUC_TWFreq[88][36] = 341;

    2185. 

  2185.                 EUC_TWFreq[45][73] = 340;

    2186. 

  2186.                 EUC_TWFreq[82][3] = 339;

    2187. 

  2187.                 EUC_TWFreq[61][36] = 338;

    2188. 

  2188.                 EUC_TWFreq[60][33] = 337;

    2189. 

  2189.                 EUC_TWFreq[38][27] = 336;

    2190. 

  2190.                 EUC_TWFreq[35][83] = 335;

    2191. 

  2191.                 EUC_TWFreq[65][24] = 334;

    2192. 

  2192.                 EUC_TWFreq[73][10] = 333;

    2193. 

  2193.                 EUC_TWFreq[41][13] = 332;

    2194. 

  2194.                 EUC_TWFreq[50][27] = 331;

    2195. 

  2195.                 EUC_TWFreq[59][50] = 330;

    2196. 

  2196.                 EUC_TWFreq[42][45] = 329;

    2197. 

  2197.                 EUC_TWFreq[55][19] = 328;

    2198. 

  2198.                 EUC_TWFreq[36][77] = 327;

    2199. 

  2199.                 EUC_TWFreq[69][31] = 326;

    2200. 

  2200.                 EUC_TWFreq[60][7] = 325;

    2201. 

  2201.                 EUC_TWFreq[40][88] = 324;

    2202. 

  2202.                 EUC_TWFreq[57][56] = 323;

    2203. 

  2203.                 EUC_TWFreq[50][50] = 322;

    2204. 

  2204.                 EUC_TWFreq[42][37] = 321;

    2205. 

  2205.                 EUC_TWFreq[38][82] = 320;

    2206. 

  2206.                 EUC_TWFreq[52][25] = 319;

    2207. 

  2207.                 EUC_TWFreq[42][67] = 318;

    2208. 

  2208.                 EUC_TWFreq[48][40] = 317;

    2209. 

  2209.                 EUC_TWFreq[45][81] = 316;

    2210. 

  2210.                 EUC_TWFreq[57][14] = 315;

    2211. 

  2211.                 EUC_TWFreq[42][13] = 314;

    2212. 

  2212.                 EUC_TWFreq[78][0] = 313;

    2213. 

  2213.                 EUC_TWFreq[35][51] = 312;

    2214. 

  2214.                 EUC_TWFreq[41][67] = 311;

    2215. 

  2215.                 EUC_TWFreq[64][23] = 310;

    2216. 

  2216.                 EUC_TWFreq[36][65] = 309;

    2217. 

  2217.                 EUC_TWFreq[48][50] = 308;

    2218. 

  2218.                 EUC_TWFreq[46][69] = 307;

    2219. 

  2219.                 EUC_TWFreq[47][89] = 306;

    2220. 

  2220.                 EUC_TWFreq[41][48] = 305;

    2221. 

  2221.                 EUC_TWFreq[60][56] = 304;

    2222. 

  2222.                 EUC_TWFreq[44][82] = 303;

    2223. 

  2223.                 EUC_TWFreq[47][35] = 302;

    2224. 

  2224.                 EUC_TWFreq[49][3] = 301;

    2225. 

  2225.                 EUC_TWFreq[49][69] = 300;

    2226. 

  2226.                 EUC_TWFreq[45][93] = 299;

    2227. 

  2227.                 EUC_TWFreq[60][34] = 298;

    2228. 

  2228.                 EUC_TWFreq[60][82] = 297;

    2229. 

  2229.                 EUC_TWFreq[61][61] = 296;

    2230. 

  2230.                 EUC_TWFreq[86][42] = 295;

    2231. 

  2231.                 EUC_TWFreq[89][60] = 294;

    2232. 

  2232.                 EUC_TWFreq[48][31] = 293;

    2233. 

  2233.                 EUC_TWFreq[35][75] = 292;

    2234. 

  2234.                 EUC_TWFreq[91][39] = 291;

    2235. 

  2235.                 EUC_TWFreq[53][19] = 290;

    2236. 

  2236.                 EUC_TWFreq[39][72] = 289;

    2237. 

  2237.                 EUC_TWFreq[69][59] = 288;

    2238. 

  2238.                 EUC_TWFreq[41][7] = 287;

    2239. 

  2239.                 EUC_TWFreq[54][13] = 286;

    2240. 

  2240.                 EUC_TWFreq[43][28] = 285;

    2241. 

  2241.                 EUC_TWFreq[36][6] = 284;

    2242. 

  2242.                 EUC_TWFreq[45][75] = 283;

    2243. 

  2243.                 EUC_TWFreq[36][61] = 282;

    2244. 

  2244.                 EUC_TWFreq[38][21] = 281;

    2245. 

  2245.                 EUC_TWFreq[45][14] = 280;

    2246. 

  2246.                 EUC_TWFreq[61][43] = 279;

    2247. 

  2247.                 EUC_TWFreq[36][63] = 278;

    2248. 

  2248.                 EUC_TWFreq[43][30] = 277;

    2249. 

  2249.                 EUC_TWFreq[46][51] = 276;

    2250. 

  2250.                 EUC_TWFreq[68][87] = 275;

    2251. 

  2251.                 EUC_TWFreq[39][26] = 274;

    2252. 

  2252.                 EUC_TWFreq[46][76] = 273;

    2253. 

  2253.                 EUC_TWFreq[36][15] = 272;

    2254. 

  2254.                 EUC_TWFreq[35][40] = 271;

    2255. 

  2255.                 EUC_TWFreq[79][60] = 270;

    2256. 

  2256.                 EUC_TWFreq[46][7] = 269;

    2257. 

  2257.                 EUC_TWFreq[65][72] = 268;

    2258. 

  2258.                 EUC_TWFreq[69][88] = 267;

    2259. 

  2259.                 EUC_TWFreq[47][18] = 266;

    2260. 

  2260.                 EUC_TWFreq[37][0] = 265;

    2261. 

  2261.                 EUC_TWFreq[37][49] = 264;

    2262. 

  2262.                 EUC_TWFreq[67][37] = 263;

    2263. 

  2263.                 EUC_TWFreq[36][91] = 262;

    2264. 

  2264.                 EUC_TWFreq[75][48] = 261;

    2265. 

  2265.                 EUC_TWFreq[75][63] = 260;

    2266. 

  2266.                 EUC_TWFreq[83][87] = 259;

    2267. 

  2267.                 EUC_TWFreq[37][44] = 258;

    2268. 

  2268.                 EUC_TWFreq[73][54] = 257;

    2269. 

  2269.                 EUC_TWFreq[51][61] = 256;

    2270. 

  2270.                 EUC_TWFreq[46][57] = 255;

    2271. 

  2271.                 EUC_TWFreq[55][21] = 254;

    2272. 

  2272.                 EUC_TWFreq[39][66] = 253;

    2273. 

  2273.                 EUC_TWFreq[47][11] = 252;

    2274. 

  2274.                 EUC_TWFreq[52][8] = 251;

    2275. 

  2275.                 EUC_TWFreq[82][81] = 250;

    2276. 

  2276.                 EUC_TWFreq[36][57] = 249;

    2277. 

  2277.                 EUC_TWFreq[38][54] = 248;

    2278. 

  2278.                 EUC_TWFreq[43][81] = 247;

    2279. 

  2279.                 EUC_TWFreq[37][42] = 246;

    2280. 

  2280.                 EUC_TWFreq[40][18] = 245;

    2281. 

  2281.                 EUC_TWFreq[80][90] = 244;

    2282. 

  2282.                 EUC_TWFreq[37][84] = 243;

    2283. 

  2283.                 EUC_TWFreq[57][15] = 242;

    2284. 

  2284.                 EUC_TWFreq[38][87] = 241;

    2285. 

  2285.                 EUC_TWFreq[37][32] = 240;

    2286. 

  2286.                 EUC_TWFreq[53][53] = 239;

    2287. 

  2287.                 EUC_TWFreq[89][29] = 238;

    2288. 

  2288.                 EUC_TWFreq[81][53] = 237;

    2289. 

  2289.                 EUC_TWFreq[75][3] = 236;

    2290. 

  2290.                 EUC_TWFreq[83][73] = 235;

    2291. 

  2291.                 EUC_TWFreq[66][13] = 234;

    2292. 

  2292.                 EUC_TWFreq[48][7] = 233;

    2293. 

  2293.                 EUC_TWFreq[46][35] = 232;

    2294. 

  2294.                 EUC_TWFreq[35][86] = 231;

    2295. 

  2295.                 EUC_TWFreq[37][20] = 230;

    2296. 

  2296.                 EUC_TWFreq[46][80] = 229;

    2297. 

  2297.                 EUC_TWFreq[38][24] = 228;

    2298. 

  2298.                 EUC_TWFreq[41][68] = 227;

    2299. 

  2299.                 EUC_TWFreq[42][21] = 226;

    2300. 

  2300.                 EUC_TWFreq[43][32] = 225;

    2301. 

  2301.                 EUC_TWFreq[38][20] = 224;

    2302. 

  2302.                 EUC_TWFreq[37][59] = 223;

    2303. 

  2303.                 EUC_TWFreq[41][77] = 222;

    2304. 

  2304.                 EUC_TWFreq[59][57] = 221;

    2305. 

  2305.                 EUC_TWFreq[68][59] = 220;

    2306. 

  2306.                 EUC_TWFreq[39][43] = 219;

    2307. 

  2307.                 EUC_TWFreq[54][39] = 218;

    2308. 

  2308.                 EUC_TWFreq[48][28] = 217;

    2309. 

  2309.                 EUC_TWFreq[54][28] = 216;

    2310. 

  2310.                 EUC_TWFreq[41][44] = 215;

    2311. 

  2311.                 EUC_TWFreq[51][64] = 214;

    2312. 

  2312.                 EUC_TWFreq[47][72] = 213;

    2313. 

  2313.                 EUC_TWFreq[62][67] = 212;

    2314. 

  2314.                 EUC_TWFreq[42][43] = 211;

    2315. 

  2315.                 EUC_TWFreq[61][38] = 210;

    2316. 

  2316.                 EUC_TWFreq[76][25] = 209;

    2317. 

  2317.                 EUC_TWFreq[48][91] = 208;

    2318. 

  2318.                 EUC_TWFreq[36][36] = 207;

    2319. 

  2319.                 EUC_TWFreq[80][32] = 206;

    2320. 

  2320.                 EUC_TWFreq[81][40] = 205;

    2321. 

  2321.                 EUC_TWFreq[37][5] = 204;

    2322. 

  2322.                 EUC_TWFreq[74][69] = 203;

    2323. 

  2323.                 EUC_TWFreq[36][82] = 202;

    2324. 

  2324.                 EUC_TWFreq[46][59] = 201;

    2325. 

  2325. 

    2326. 

  2326.                 #endregion

    2327. 

  2327.             }

    2328. 

  2328.         }

    2329. 

  2329. 

    2330. 

  2330.         #endregion

    2331. 

  2331. 

    2332. 

  2332.         #region ToByteArray.....

    2333. 

  2333. 

    2334. 

  2334.         /// <summary>

    2335. 

  2335.         /// 将此实例中的指定 <see cref="sbyte"/> 字符数组转换到 <see cref="byte"/> 字符数组。

    2336. 

  2336.         /// </summary>

    2337. 

  2337.         /// <param name="sbyteArray">要转换的 <see cref="sbyte"/> 字符数组</param>

    2338. 

  2338.         /// <returns>返回转换后的 <see cref="byte"/> 字符数组</returns>

    2339. 

  2339.         public static byte[] ToByteArray(sbyte[] sbyteArray)

    2340. 

  2340.         {

    2341. 

  2341.             byte[] byteArray = new byte[sbyteArray.Length];

    2342. 

  2342.             for (int index = 0; index < sbyteArray.Length; index++)

    2343. 

  2343.                 byteArray[index] = (byte)sbyteArray[index];

    2344. 

  2344.             return byteArray;

    2345. 

  2345.         }

    2346. 

  2346. 

    2347. 

  2347.         /// <summary>

    2348. 

  2348.         /// 将此实例中的指定字符串转换到 <see cref="byte"/> 字符数组。

    2349. 

  2349.         /// </summary>

    2350. 

  2350.         /// <param name="sourceString">要转换的字符串</param>

    2351. 

  2351.         /// <returns>返回转换后的 <see cref="byte"/> 字符数组</returns>

    2352. 

  2352.         public static byte[] ToByteArray(string sourceString)

    2353. 

  2353.         {

    2354. 

  2354.             byte[] byteArray = new byte[sourceString.Length];

    2355. 

  2355.             for (int index = 0; index < sourceString.Length; index++)

    2356. 

  2356.                 byteArray[index] = (byte)sourceString[index];

    2357. 

  2357.             return byteArray;

    2358. 

  2358.         }

    2359. 

  2359. 

    2360. 

  2360.         /// <summary>

    2361. 

  2361.         /// 将此实例中的指定 <see cref="object"/> 数组转换到 <see cref="byte"/> 字符数组。

    2362. 

  2362.         /// </summary>

    2363. 

  2363.         /// <param name="tempObjectArray">要转换的 <see cref="object"/> 字符数组</param>

    2364. 

  2364.         /// <returns>返回转换后的 <see cref="byte"/> 字符数组</returns>

    2365. 

  2365.         public static byte[] ToByteArray(object[] tempObjectArray)

    2366. 

  2366.         {

    2367. 

  2367.             byte[] byteArray = new byte[tempObjectArray.Length];

    2368. 

  2368.             for (int index = 0; index < tempObjectArray.Length; index++)

    2369. 

  2369.                 byteArray[index] = (byte)tempObjectArray[index];

    2370. 

  2370.             return byteArray;

    2371. 

  2371.         }

    2372. 

  2372. 

    2373. 

  2373.         #endregion

    2374. 

  2374. 

    2375. 

  2375.         #region ToSByteArray.....

    2376. 

  2376. 

    2377. 

  2377.         /// <summary>

    2378. 

  2378.         /// 将此实例中的指定 <see cref="byte"/> 字符数组转换到 <see cref="sbyte"/> 字符数组。

    2379. 

  2379.         /// </summary>

    2380. 

  2380.         /// <param name="byteArray">要转换的 <see cref="byte"/> 字符数组</param>

    2381. 

  2381.         /// <returns>返回转换后的 <see cref="sbyte"/> 字符数组</returns>

    2382. 

  2382.         public static sbyte[] ToSByteArray(byte[] byteArray)

    2383. 

  2383.         {

    2384. 

  2384.             sbyte[] sbyteArray = new sbyte[byteArray.Length];

    2385. 

  2385.             for (int index = 0; index < byteArray.Length; index++)

    2386. 

  2386.                 sbyteArray[index] = (sbyte)byteArray[index];

    2387. 

  2387.             return sbyteArray;

    2388. 

  2388.         }

    2389. 

  2389. 

    2390. 

  2390.         #endregion

    2391. 

  2391. 

    2392. 

  2392.         #region ReadInput.....

    2393. 

  2393. 

    2394. 

  2394.         /// <summary>从流读取字节序列,并将此流中的位置提升读取的字节数.</summary>

    2395. 

  2395.         /// <param name="sourceStream">要读取的流.</param>

    2396. 

  2396.         /// <param name="target">字节数组。此方法返回时,该缓冲区包含指定的字符数组,该数组的 start 和 (start + count-1) 之间的值由从当前源中读取的字节替换。</param>

    2397. 

  2397.         /// <param name="start">buffer 中的从零开始的字节偏移量,从此处开始存储从当前流中读取的数据。.</param>

    2398. 

  2398.         /// <param name="count">要从当前流中最多读取的字节数。</param>

    2399. 

  2399.         /// <returns>读入缓冲区中的总字节数。如果当前可用的字节数没有请求的字节数那么多,则总字节数可能小于请求的字节数,或者如果已到达流的末尾,则为零 (0)。</returns>

    2400. 

  2400.         /// <exception cref="ArgumentException">start 与 count 的和大于缓冲区长度。</exception>

    2401. 

  2401.         /// <exception cref="ArgumentNullException">target 为空引用(Visual Basic 中为 Nothing)。</exception>

    2402. 

  2402.         /// <exception cref="ArgumentOutOfRangeException">offset 或 count 为负。</exception>

    2403. 

  2403.         /// <exception cref="System.IO.IOException">发生 I/O 错误。</exception>

    2404. 

  2404.         /// <exception cref="NotSupportedException">流不支持读取。</exception>

    2405. 

  2405.         /// <exception cref="ObjectDisposedException">在流关闭后调用方法。</exception>

    2406. 

  2406.         public static int ReadInput(System.IO.Stream sourceStream, ref sbyte[] target, int start, int count)

    2407. 

  2407.         {

    2408. 

  2408.             // Returns 0 bytes if not enough space in target

    2409. 

  2409.             if (target.Length == 0)

    2410. 

  2410.                 return 0;

    2411. 

  2411. 

    2412. 

  2412.             byte[] receiver = new byte[target.Length];

    2413. 

  2413.             int bytesRead = sourceStream.Read(receiver, start, count);

    2414. 

  2414. 

    2415. 

  2415.             // Returns -1 if EOF

    2416. 

  2416.             if (bytesRead == 0)

    2417. 

  2417.                 return -1;

    2418. 

  2418. 

    2419. 

  2419.             for (int i = start; i < start + bytesRead; i++)

    2420. 

  2420.                 target[i] = (sbyte)receiver[i];

    2421. 

  2421. 

    2422. 

  2422.             return bytesRead;

    2423. 

  2423.         }

    2424. 

  2424. 

    2425. 

  2425.         /// <summary>从字符系列读取字节序列,并将此字符系列中的位置提升读取的字节数。</summary>

    2426. 

  2426.         /// <param name="sourceTextReader">要读取的流。</param>

    2427. 

  2427.         /// <param name="target">字节数组。此方法返回时,该缓冲区包含指定的字符数组,该数组的 start 和 (start + count-1) 之间的值由从当前源中读取的字节替换。</param>

    2428. 

  2428.         /// <param name="start">buffer 中的从零开始的字节偏移量,从此处开始存储从当前流中读取的数据。.</param>

    2429. 

  2429.         /// <param name="count">要从当前流中最多读取的字节数。</param>

    2430. 

  2430.         /// <returns>读入缓冲区中的总字节数。如果当前可用的字节数没有请求的字节数那么多,则总字节数可能小于请求的字节数,或者如果已到达流的末尾,则为零 (0)。</returns>

    2431. 

  2431.         /// <exception cref="ArgumentException">start 与 count 的和大于缓冲区长度。</exception>

    2432. 

  2432.         /// <exception cref="ArgumentNullException">target 为空引用(Visual Basic 中为 Nothing)。</exception>

    2433. 

  2433.         /// <exception cref="ArgumentOutOfRangeException">offset 或 count 为负。</exception>

    2434. 

  2434.         /// <exception cref="System.IO.IOException">发生 I/O 错误。</exception>

    2435. 

  2435.         /// <exception cref="NotSupportedException">流不支持读取。</exception>

    2436. 

  2436.         /// <exception cref="ObjectDisposedException">在流关闭后调用方法。</exception>

    2437. 

  2437.         public static int ReadInput(System.IO.TextReader sourceTextReader, ref sbyte[] target, int start, int count)

    2438. 

  2438.         {

    2439. 

  2439.             // Returns 0 bytes if not enough space in target

    2440. 

  2440.             if (target.Length == 0)

    2441. 

  2441.                 return 0;

    2442. 

  2442. 

    2443. 

  2443.             char[] charArray = new char[target.Length];

    2444. 

  2444.             int bytesRead = sourceTextReader.Read(charArray, start, count);

    2445. 

  2445. 

    2446. 

  2446.             // Returns -1 if EOF

    2447. 

  2447.             if (bytesRead == 0)

    2448. 

  2448.                 return -1;

    2449. 

  2449. 

    2450. 

  2450.             for (int index = start; index < start + bytesRead; index++)

    2451. 

  2451.                 target[index] = (sbyte)charArray[index];

    2452. 

  2452. 

    2453. 

  2453.             return bytesRead;

    2454. 

  2454.         }

    2455. 

  2455. 

    2456. 

  2456.         #endregion

    2457. 

  2457. 

    2458. 

  2458.         #region FileLength.....

    2459. 

  2459. 

    2460. 

  2460.         /// <summary>

    2461. 

  2461.         /// 检测当前文件的大小

    2462. 

  2462.         /// </summary>

    2463. 

  2463.         /// <param name="file">被检测的文件</param>

    2464. 

  2464.         /// <returns>当前文件的大小。</returns>

    2465. 

  2465.         public static long FileLength(System.IO.FileInfo file)

    2466. 

  2466.         {

    2467. 

  2467.             if (System.IO.Directory.Exists(file.FullName))

    2468. 

  2468.                 return 0;

    2469. 

  2469.             else

    2470. 

  2470.                 return file.Length;

    2471. 

  2471.         }

    2472. 

  2472. 

    2473. 

  2473.         #endregion

    2474. 

  2474. 

    2475. 

  2475.         #region Identity.....

    2476. 

  2476. 

    2477. 

  2477.         /// <summary>

    2478. 

  2478.         /// This method returns the literal value received

    2479. 

  2479.         /// </summary>

    2480. 

  2480.         /// <param name="literal">The literal to return</param>

    2481. 

  2481.         /// <returns>The received value</returns>

    2482. 

  2482.         public static long Identity(long literal)

    2483. 

  2483.         {

    2484. 

  2484.             return literal;

    2485. 

  2485.         }

    2486. 

  2486. 

    2487. 

  2487.         /// <summary>

    2488. 

  2488.         /// This method returns the literal value received

    2489. 

  2489.         /// </summary>

    2490. 

  2490.         /// <param name="literal">The literal to return</param>

    2491. 

  2491.         /// <returns>The received value</returns>

    2492. 

  2492.         public static ulong Identity(ulong literal)

    2493. 

  2493.         {

    2494. 

  2494.             return literal;

    2495. 

  2495.         }

    2496. 

  2496. 

    2497. 

  2497.         /// <summary>

    2498. 

  2498.         /// This method returns the literal value received

    2499. 

  2499.         /// </summary>

    2500. 

  2500.         /// <param name="literal">The literal to return</param>

    2501. 

  2501.         /// <returns>The received value</returns>

    2502. 

  2502.         public static float Identity(float literal)

    2503. 

  2503.         {

    2504. 

  2504.             return literal;

    2505. 

  2505.         }

    2506. 

  2506. 

    2507. 

  2507.         /// <summary>

    2508. 

  2508.         /// This method returns the literal value received

    2509. 

  2509.         /// </summary>

    2510. 

  2510.         /// <param name="literal">The literal to return</param>

    2511. 

  2511.         /// <returns>The received value</returns>

    2512. 

  2512.         public static double Identity(double literal)

    2513. 

  2513.         {

    2514. 

  2514.             return literal;

    2515. 

  2515.         }

    2516. 

  2516. 

    2517. 

  2517.         #endregion

    2518. 

  2518. 

    2519. 

  2519.         #endregion

    2520. 

  2520.     }

    2521. 

  2521. 

    2522. 

  2522.     #endregion

    2523. 

  2523. }

    2524. 

  2524.