freeglut_stroke_roman.c
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:47k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /*
  2.  * freeglut_stroke_roman.c
  3.  *
  4.  * freeglut Roman stroke font definition
  5.  *
  6.  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
  7.  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
  8.  * Creation date: Thu Dec 16 1999
  9.  *
  10.  * Permission is hereby granted, free of charge, to any person obtaining a
  11.  * copy of this software and associated documentation files (the "Software"),
  12.  * to deal in the Software without restriction, including without limitation
  13.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14.  * and/or sell copies of the Software, and to permit persons to whom the
  15.  * Software is furnished to do so, subject to the following conditions:
  16.  *
  17.  * The above copyright notice and this permission notice shall be included
  18.  * in all copies or substantial portions of the Software.
  19.  *
  20.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23.  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24.  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26.  */
  27. /* This file has been automatically generated by the genstroke utility. */
  28. #include <GL/freeglut.h>
  29. #include "freeglut_internal.h"
  30. /* char: 0x20 */
  31. static const SFG_StrokeStrip ch32st[] =
  32. {
  33.   { 0, NULL }
  34. };
  35. static const SFG_StrokeChar ch32 = {104.762f,0,ch32st};
  36. /* char: 0x21 */
  37. static const SFG_StrokeVertex ch33st0[] =
  38. {
  39.  {13.3819f,100.0f},
  40.  {13.3819f,33.3333f}
  41. };
  42. static const SFG_StrokeVertex ch33st1[] =
  43. {
  44.  {13.3819f,9.5238f},
  45.  {8.62f,4.7619f},
  46.  {13.3819f,0.0f},
  47.  {18.1438f,4.7619f},
  48.  {13.3819f,9.5238f}
  49. };
  50. static const SFG_StrokeStrip ch33st[] =
  51. {
  52.  {2,ch33st0},
  53.  {5,ch33st1}
  54. };
  55. static const SFG_StrokeChar ch33 = {26.6238f,2,ch33st};
  56. /* char: 0x22 */
  57. static const SFG_StrokeVertex ch34st0[] =
  58. {
  59.  {4.02f,100.0f},
  60.  {4.02f,66.6667f}
  61. };
  62. static const SFG_StrokeVertex ch34st1[] =
  63. {
  64.  {42.1152f,100.0f},
  65.  {42.1152f,66.6667f}
  66. };
  67. static const SFG_StrokeStrip ch34st[] =
  68. {
  69.  {2,ch34st0},
  70.  {2,ch34st1}
  71. };
  72. static const SFG_StrokeChar ch34 = {51.4352f,2,ch34st};
  73. /* char: 0x23 */
  74. static const SFG_StrokeVertex ch35st0[] =
  75. {
  76.  {41.2952f,119.048f},
  77.  {7.9619f,-33.3333f}
  78. };
  79. static const SFG_StrokeVertex ch35st1[] =
  80. {
  81.  {69.8667f,119.048f},
  82.  {36.5333f,-33.3333f}
  83. };
  84. static const SFG_StrokeVertex ch35st2[] =
  85. {
  86.  {7.9619f,57.1429f},
  87.  {74.6286f,57.1429f}
  88. };
  89. static const SFG_StrokeVertex ch35st3[] =
  90. {
  91.  {3.2f,28.5714f},
  92.  {69.8667f,28.5714f}
  93. };
  94. static const SFG_StrokeStrip ch35st[] =
  95. {
  96.  {2,ch35st0},
  97.  {2,ch35st1},
  98.  {2,ch35st2},
  99.  {2,ch35st3}
  100. };
  101. static const SFG_StrokeChar ch35 = {79.4886f,4,ch35st};
  102. /* char: 0x24 */
  103. static const SFG_StrokeVertex ch36st0[] =
  104. {
  105.  {28.6295f,119.048f},
  106.  {28.6295f,-19.0476f}
  107. };
  108. static const SFG_StrokeVertex ch36st1[] =
  109. {
  110.  {47.6771f,119.048f},
  111.  {47.6771f,-19.0476f}
  112. };
  113. static const SFG_StrokeVertex ch36st2[] =
  114. {
  115.  {71.4867f,85.7143f},
  116.  {61.9629f,95.2381f},
  117.  {47.6771f,100.0f},
  118.  {28.6295f,100.0f},
  119.  {14.3438f,95.2381f},
  120.  {4.82f,85.7143f},
  121.  {4.82f,76.1905f},
  122.  {9.5819f,66.6667f},
  123.  {14.3438f,61.9048f},
  124.  {23.8676f,57.1429f},
  125.  {52.439f,47.619f},
  126.  {61.9629f,42.8571f},
  127.  {66.7248f,38.0952f},
  128.  {71.4867f,28.5714f},
  129.  {71.4867f,14.2857f},
  130.  {61.9629f,4.7619f},
  131.  {47.6771f,0.0f},
  132.  {28.6295f,0.0f},
  133.  {14.3438f,4.7619f},
  134.  {4.82f,14.2857f}
  135. };
  136. static const SFG_StrokeStrip ch36st[] =
  137. {
  138.  {2,ch36st0},
  139.  {2,ch36st1},
  140.  {20,ch36st2}
  141. };
  142. static const SFG_StrokeChar ch36 = {76.2067f,3,ch36st};
  143. /* char: 0x25 */
  144. static const SFG_StrokeVertex ch37st0[] =
  145. {
  146.  {92.0743f,100.0f},
  147.  {6.36f,0.0f}
  148. };
  149. static const SFG_StrokeVertex ch37st1[] =
  150. {
  151.  {30.1695f,100.0f},
  152.  {39.6933f,90.4762f},
  153.  {39.6933f,80.9524f},
  154.  {34.9314f,71.4286f},
  155.  {25.4076f,66.6667f},
  156.  {15.8838f,66.6667f},
  157.  {6.36f,76.1905f},
  158.  {6.36f,85.7143f},
  159.  {11.1219f,95.2381f},
  160.  {20.6457f,100.0f},
  161.  {30.1695f,100.0f},
  162.  {39.6933f,95.2381f},
  163.  {53.979f,90.4762f},
  164.  {68.2648f,90.4762f},
  165.  {82.5505f,95.2381f},
  166.  {92.0743f,100.0f}
  167. };
  168. static const SFG_StrokeVertex ch37st2[] =
  169. {
  170.  {73.0267f,33.3333f},
  171.  {63.5029f,28.5714f},
  172.  {58.741f,19.0476f},
  173.  {58.741f,9.5238f},
  174.  {68.2648f,0.0f},
  175.  {77.7886f,0.0f},
  176.  {87.3124f,4.7619f},
  177.  {92.0743f,14.2857f},
  178.  {92.0743f,23.8095f},
  179.  {82.5505f,33.3333f},
  180.  {73.0267f,33.3333f}
  181. };
  182. static const SFG_StrokeStrip ch37st[] =
  183. {
  184.  {2,ch37st0},
  185.  {16,ch37st1},
  186.  {11,ch37st2}
  187. };
  188. static const SFG_StrokeChar ch37 = {96.5743f,3,ch37st};
  189. /* char: 0x26 */
  190. static const SFG_StrokeVertex ch38st0[] =
  191. {
  192.  {101.218f,57.1429f},
  193.  {101.218f,61.9048f},
  194.  {96.4562f,66.6667f},
  195.  {91.6943f,66.6667f},
  196.  {86.9324f,61.9048f},
  197.  {82.1705f,52.381f},
  198.  {72.6467f,28.5714f},
  199.  {63.1229f,14.2857f},
  200.  {53.599f,4.7619f},
  201.  {44.0752f,0.0f},
  202.  {25.0276f,0.0f},
  203.  {15.5038f,4.7619f},
  204.  {10.7419f,9.5238f},
  205.  {5.98f,19.0476f},
  206.  {5.98f,28.5714f},
  207.  {10.7419f,38.0952f},
  208.  {15.5038f,42.8571f},
  209.  {48.8371f,61.9048f},
  210.  {53.599f,66.6667f},
  211.  {58.361f,76.1905f},
  212.  {58.361f,85.7143f},
  213.  {53.599f,95.2381f},
  214.  {44.0752f,100.0f},
  215.  {34.5514f,95.2381f},
  216.  {29.7895f,85.7143f},
  217.  {29.7895f,76.1905f},
  218.  {34.5514f,61.9048f},
  219.  {44.0752f,47.619f},
  220.  {67.8848f,14.2857f},
  221.  {77.4086f,4.7619f},
  222.  {86.9324f,0.0f},
  223.  {96.4562f,0.0f},
  224.  {101.218f,4.7619f},
  225.  {101.218f,9.5238f}
  226. };
  227. static const SFG_StrokeStrip ch38st[] =
  228. {
  229.  {34,ch38st0}
  230. };
  231. static const SFG_StrokeChar ch38 = {101.758f,1,ch38st};
  232. /* char: 0x27 */
  233. static const SFG_StrokeVertex ch39st0[] =
  234. {
  235.  {4.44f,100.0f},
  236.  {4.44f,66.6667f}
  237. };
  238. static const SFG_StrokeStrip ch39st[] =
  239. {
  240.  {2,ch39st0}
  241. };
  242. static const SFG_StrokeChar ch39 = {13.62f,1,ch39st};
  243. /* char: 0x28 */
  244. static const SFG_StrokeVertex ch40st0[] =
  245. {
  246.  {40.9133f,119.048f},
  247.  {31.3895f,109.524f},
  248.  {21.8657f,95.2381f},
  249.  {12.3419f,76.1905f},
  250.  {7.58f,52.381f},
  251.  {7.58f,33.3333f},
  252.  {12.3419f,9.5238f},
  253.  {21.8657f,-9.5238f},
  254.  {31.3895f,-23.8095f},
  255.  {40.9133f,-33.3333f}
  256. };
  257. static const SFG_StrokeStrip ch40st[] =
  258. {
  259.  {10,ch40st0}
  260. };
  261. static const SFG_StrokeChar ch40 = {47.1733f,1,ch40st};
  262. /* char: 0x29 */
  263. static const SFG_StrokeVertex ch41st0[] =
  264. {
  265.  {5.28f,119.048f},
  266.  {14.8038f,109.524f},
  267.  {24.3276f,95.2381f},
  268.  {33.8514f,76.1905f},
  269.  {38.6133f,52.381f},
  270.  {38.6133f,33.3333f},
  271.  {33.8514f,9.5238f},
  272.  {24.3276f,-9.5238f},
  273.  {14.8038f,-23.8095f},
  274.  {5.28f,-33.3333f}
  275. };
  276. static const SFG_StrokeStrip ch41st[] =
  277. {
  278.  {10,ch41st0}
  279. };
  280. static const SFG_StrokeChar ch41 = {47.5333f,1,ch41st};
  281. /* char: 0x2a */
  282. static const SFG_StrokeVertex ch42st0[] =
  283. {
  284.  {30.7695f,71.4286f},
  285.  {30.7695f,14.2857f}
  286. };
  287. static const SFG_StrokeVertex ch42st1[] =
  288. {
  289.  {6.96f,57.1429f},
  290.  {54.579f,28.5714f}
  291. };
  292. static const SFG_StrokeVertex ch42st2[] =
  293. {
  294.  {54.579f,57.1429f},
  295.  {6.96f,28.5714f}
  296. };
  297. static const SFG_StrokeStrip ch42st[] =
  298. {
  299.  {2,ch42st0},
  300.  {2,ch42st1},
  301.  {2,ch42st2}
  302. };
  303. static const SFG_StrokeChar ch42 = {59.439f,3,ch42st};
  304. /* char: 0x2b */
  305. static const SFG_StrokeVertex ch43st0[] =
  306. {
  307.  {48.8371f,85.7143f},
  308.  {48.8371f,0.0f}
  309. };
  310. static const SFG_StrokeVertex ch43st1[] =
  311. {
  312.  {5.98f,42.8571f},
  313.  {91.6943f,42.8571f}
  314. };
  315. static const SFG_StrokeStrip ch43st[] =
  316. {
  317.  {2,ch43st0},
  318.  {2,ch43st1}
  319. };
  320. static const SFG_StrokeChar ch43 = {97.2543f,2,ch43st};
  321. /* char: 0x2c */
  322. static const SFG_StrokeVertex ch44st0[] =
  323. {
  324.  {18.2838f,4.7619f},
  325.  {13.5219f,0.0f},
  326.  {8.76f,4.7619f},
  327.  {13.5219f,9.5238f},
  328.  {18.2838f,4.7619f},
  329.  {18.2838f,-4.7619f},
  330.  {13.5219f,-14.2857f},
  331.  {8.76f,-19.0476f}
  332. };
  333. static const SFG_StrokeStrip ch44st[] =
  334. {
  335.  {8,ch44st0}
  336. };
  337. static const SFG_StrokeChar ch44 = {26.0638f,1,ch44st};
  338. /* char: 0x2d */
  339. static const SFG_StrokeVertex ch45st0[] =
  340. {
  341.  {7.38f,42.8571f},
  342.  {93.0943f,42.8571f}
  343. };
  344. static const SFG_StrokeStrip ch45st[] =
  345. {
  346.  {2,ch45st0}
  347. };
  348. static const SFG_StrokeChar ch45 = {100.754f,1,ch45st};
  349. /* char: 0x2e */
  350. static const SFG_StrokeVertex ch46st0[] =
  351. {
  352.  {13.1019f,9.5238f},
  353.  {8.34f,4.7619f},
  354.  {13.1019f,0.0f},
  355.  {17.8638f,4.7619f},
  356.  {13.1019f,9.5238f}
  357. };
  358. static const SFG_StrokeStrip ch46st[] =
  359. {
  360.  {5,ch46st0}
  361. };
  362. static const SFG_StrokeChar ch46 = {26.4838f,1,ch46st};
  363. /* char: 0x2f */
  364. static const SFG_StrokeVertex ch47st0[] =
  365. {
  366.  {7.24f,-14.2857f},
  367.  {73.9067f,100.0f}
  368. };
  369. static const SFG_StrokeStrip ch47st[] =
  370. {
  371.  {2,ch47st0}
  372. };
  373. static const SFG_StrokeChar ch47 = {82.1067f,1,ch47st};
  374. /* char: 0x30 */
  375. static const SFG_StrokeVertex ch48st0[] =
  376. {
  377.  {33.5514f,100.0f},
  378.  {19.2657f,95.2381f},
  379.  {9.7419f,80.9524f},
  380.  {4.98f,57.1429f},
  381.  {4.98f,42.8571f},
  382.  {9.7419f,19.0476f},
  383.  {19.2657f,4.7619f},
  384.  {33.5514f,0.0f},
  385.  {43.0752f,0.0f},
  386.  {57.361f,4.7619f},
  387.  {66.8848f,19.0476f},
  388.  {71.6467f,42.8571f},
  389.  {71.6467f,57.1429f},
  390.  {66.8848f,80.9524f},
  391.  {57.361f,95.2381f},
  392.  {43.0752f,100.0f},
  393.  {33.5514f,100.0f}
  394. };
  395. static const SFG_StrokeStrip ch48st[] =
  396. {
  397.  {17,ch48st0}
  398. };
  399. static const SFG_StrokeChar ch48 = {77.0667f,1,ch48st};
  400. /* char: 0x31 */
  401. static const SFG_StrokeVertex ch49st0[] =
  402. {
  403.  {11.82f,80.9524f},
  404.  {21.3438f,85.7143f},
  405.  {35.6295f,100.0f},
  406.  {35.6295f,0.0f}
  407. };
  408. static const SFG_StrokeStrip ch49st[] =
  409. {
  410.  {4,ch49st0}
  411. };
  412. static const SFG_StrokeChar ch49 = {66.5295f,1,ch49st};
  413. /* char: 0x32 */
  414. static const SFG_StrokeVertex ch50st0[] =
  415. {
  416.  {10.1819f,76.1905f},
  417.  {10.1819f,80.9524f},
  418.  {14.9438f,90.4762f},
  419.  {19.7057f,95.2381f},
  420.  {29.2295f,100.0f},
  421.  {48.2771f,100.0f},
  422.  {57.801f,95.2381f},
  423.  {62.5629f,90.4762f},
  424.  {67.3248f,80.9524f},
  425.  {67.3248f,71.4286f},
  426.  {62.5629f,61.9048f},
  427.  {53.039f,47.619f},
  428.  {5.42f,0.0f},
  429.  {72.0867f,0.0f}
  430. };
  431. static const SFG_StrokeStrip ch50st[] =
  432. {
  433.  {14,ch50st0}
  434. };
  435. static const SFG_StrokeChar ch50 = {77.6467f,1,ch50st};
  436. /* char: 0x33 */
  437. static const SFG_StrokeVertex ch51st0[] =
  438. {
  439.  {14.5238f,100.0f},
  440.  {66.9048f,100.0f},
  441.  {38.3333f,61.9048f},
  442.  {52.619f,61.9048f},
  443.  {62.1429f,57.1429f},
  444.  {66.9048f,52.381f},
  445.  {71.6667f,38.0952f},
  446.  {71.6667f,28.5714f},
  447.  {66.9048f,14.2857f},
  448.  {57.381f,4.7619f},
  449.  {43.0952f,0.0f},
  450.  {28.8095f,0.0f},
  451.  {14.5238f,4.7619f},
  452.  {9.7619f,9.5238f},
  453.  {5.0f,19.0476f}
  454. };
  455. static const SFG_StrokeStrip ch51st[] =
  456. {
  457.  {15,ch51st0}
  458. };
  459. static const SFG_StrokeChar ch51 = {77.0467f,1,ch51st};
  460. /* char: 0x34 */
  461. static const SFG_StrokeVertex ch52st0[] =
  462. {
  463.  {51.499f,100.0f},
  464.  {3.88f,33.3333f},
  465.  {75.3086f,33.3333f}
  466. };
  467. static const SFG_StrokeVertex ch52st1[] =
  468. {
  469.  {51.499f,100.0f},
  470.  {51.499f,0.0f}
  471. };
  472. static const SFG_StrokeStrip ch52st[] =
  473. {
  474.  {3,ch52st0},
  475.  {2,ch52st1}
  476. };
  477. static const SFG_StrokeChar ch52 = {80.1686f,2,ch52st};
  478. /* char: 0x35 */
  479. static const SFG_StrokeVertex ch53st0[] =
  480. {
  481.  {62.0029f,100.0f},
  482.  {14.3838f,100.0f},
  483.  {9.6219f,57.1429f},
  484.  {14.3838f,61.9048f},
  485.  {28.6695f,66.6667f},
  486.  {42.9552f,66.6667f},
  487.  {57.241f,61.9048f},
  488.  {66.7648f,52.381f},
  489.  {71.5267f,38.0952f},
  490.  {71.5267f,28.5714f},
  491.  {66.7648f,14.2857f},
  492.  {57.241f,4.7619f},
  493.  {42.9552f,0.0f},
  494.  {28.6695f,0.0f},
  495.  {14.3838f,4.7619f},
  496.  {9.6219f,9.5238f},
  497.  {4.86f,19.0476f}
  498. };
  499. static const SFG_StrokeStrip ch53st[] =
  500. {
  501.  {17,ch53st0}
  502. };
  503. static const SFG_StrokeChar ch53 = {77.6867f,1,ch53st};
  504. /* char: 0x36 */
  505. static const SFG_StrokeVertex ch54st0[] =
  506. {
  507.  {62.7229f,85.7143f},
  508.  {57.961f,95.2381f},
  509.  {43.6752f,100.0f},
  510.  {34.1514f,100.0f},
  511.  {19.8657f,95.2381f},
  512.  {10.3419f,80.9524f},
  513.  {5.58f,57.1429f},
  514.  {5.58f,33.3333f},
  515.  {10.3419f,14.2857f},
  516.  {19.8657f,4.7619f},
  517.  {34.1514f,0.0f},
  518.  {38.9133f,0.0f},
  519.  {53.199f,4.7619f},
  520.  {62.7229f,14.2857f},
  521.  {67.4848f,28.5714f},
  522.  {67.4848f,33.3333f},
  523.  {62.7229f,47.619f},
  524.  {53.199f,57.1429f},
  525.  {38.9133f,61.9048f},
  526.  {34.1514f,61.9048f},
  527.  {19.8657f,57.1429f},
  528.  {10.3419f,47.619f},
  529.  {5.58f,33.3333f}
  530. };
  531. static const SFG_StrokeStrip ch54st[] =
  532. {
  533.  {23,ch54st0}
  534. };
  535. static const SFG_StrokeChar ch54 = {73.8048f,1,ch54st};
  536. /* char: 0x37 */
  537. static const SFG_StrokeVertex ch55st0[] =
  538. {
  539.  {72.2267f,100.0f},
  540.  {24.6076f,0.0f}
  541. };
  542. static const SFG_StrokeVertex ch55st1[] =
  543. {
  544.  {5.56f,100.0f},
  545.  {72.2267f,100.0f}
  546. };
  547. static const SFG_StrokeStrip ch55st[] =
  548. {
  549.  {2,ch55st0},
  550.  {2,ch55st1}
  551. };
  552. static const SFG_StrokeChar ch55 = {77.2267f,2,ch55st};
  553. /* char: 0x38 */
  554. static const SFG_StrokeVertex ch56st0[] =
  555. {
  556.  {29.4095f,100.0f},
  557.  {15.1238f,95.2381f},
  558.  {10.3619f,85.7143f},
  559.  {10.3619f,76.1905f},
  560.  {15.1238f,66.6667f},
  561.  {24.6476f,61.9048f},
  562.  {43.6952f,57.1429f},
  563.  {57.981f,52.381f},
  564.  {67.5048f,42.8571f},
  565.  {72.2667f,33.3333f},
  566.  {72.2667f,19.0476f},
  567.  {67.5048f,9.5238f},
  568.  {62.7429f,4.7619f},
  569.  {48.4571f,0.0f},
  570.  {29.4095f,0.0f},
  571.  {15.1238f,4.7619f},
  572.  {10.3619f,9.5238f},
  573.  {5.6f,19.0476f},
  574.  {5.6f,33.3333f},
  575.  {10.3619f,42.8571f},
  576.  {19.8857f,52.381f},
  577.  {34.1714f,57.1429f},
  578.  {53.219f,61.9048f},
  579.  {62.7429f,66.6667f},
  580.  {67.5048f,76.1905f},
  581.  {67.5048f,85.7143f},
  582.  {62.7429f,95.2381f},
  583.  {48.4571f,100.0f},
  584.  {29.4095f,100.0f}
  585. };
  586. static const SFG_StrokeStrip ch56st[] =
  587. {
  588.  {29,ch56st0}
  589. };
  590. static const SFG_StrokeChar ch56 = {77.6667f,1,ch56st};
  591. /* char: 0x39 */
  592. static const SFG_StrokeVertex ch57st0[] =
  593. {
  594.  {68.5048f,66.6667f},
  595.  {63.7429f,52.381f},
  596.  {54.219f,42.8571f},
  597.  {39.9333f,38.0952f},
  598.  {35.1714f,38.0952f},
  599.  {20.8857f,42.8571f},
  600.  {11.3619f,52.381f},
  601.  {6.6f,66.6667f},
  602.  {6.6f,71.4286f},
  603.  {11.3619f,85.7143f},
  604.  {20.8857f,95.2381f},
  605.  {35.1714f,100.0f},
  606.  {39.9333f,100.0f},
  607.  {54.219f,95.2381f},
  608.  {63.7429f,85.7143f},
  609.  {68.5048f,66.6667f},
  610.  {68.5048f,42.8571f},
  611.  {63.7429f,19.0476f},
  612.  {54.219f,4.7619f},
  613.  {39.9333f,0.0f},
  614.  {30.4095f,0.0f},
  615.  {16.1238f,4.7619f},
  616.  {11.3619f,14.2857f}
  617. };
  618. static const SFG_StrokeStrip ch57st[] =
  619. {
  620.  {23,ch57st0}
  621. };
  622. static const SFG_StrokeChar ch57 = {74.0648f,1,ch57st};
  623. /* char: 0x3a */
  624. static const SFG_StrokeVertex ch58st0[] =
  625. {
  626.  {14.0819f,66.6667f},
  627.  {9.32f,61.9048f},
  628.  {14.0819f,57.1429f},
  629.  {18.8438f,61.9048f},
  630.  {14.0819f,66.6667f}
  631. };
  632. static const SFG_StrokeVertex ch58st1[] =
  633. {
  634.  {14.0819f,9.5238f},
  635.  {9.32f,4.7619f},
  636.  {14.0819f,0.0f},
  637.  {18.8438f,4.7619f},
  638.  {14.0819f,9.5238f}
  639. };
  640. static const SFG_StrokeStrip ch58st[] =
  641. {
  642.  {5,ch58st0},
  643.  {5,ch58st1}
  644. };
  645. static const SFG_StrokeChar ch58 = {26.2238f,2,ch58st};
  646. /* char: 0x3b */
  647. static const SFG_StrokeVertex ch59st0[] =
  648. {
  649.  {12.9619f,66.6667f},
  650.  {8.2f,61.9048f},
  651.  {12.9619f,57.1429f},
  652.  {17.7238f,61.9048f},
  653.  {12.9619f,66.6667f}
  654. };
  655. static const SFG_StrokeVertex ch59st1[] =
  656. {
  657.  {17.7238f,4.7619f},
  658.  {12.9619f,0.0f},
  659.  {8.2f,4.7619f},
  660.  {12.9619f,9.5238f},
  661.  {17.7238f,4.7619f},
  662.  {17.7238f,-4.7619f},
  663.  {12.9619f,-14.2857f},
  664.  {8.2f,-19.0476f}
  665. };
  666. static const SFG_StrokeStrip ch59st[] =
  667. {
  668.  {5,ch59st0},
  669.  {8,ch59st1}
  670. };
  671. static const SFG_StrokeChar ch59 = {26.3038f,2,ch59st};
  672. /* char: 0x3c */
  673. static const SFG_StrokeVertex ch60st0[] =
  674. {
  675.  {79.2505f,85.7143f},
  676.  {3.06f,42.8571f},
  677.  {79.2505f,0.0f}
  678. };
  679. static const SFG_StrokeStrip ch60st[] =
  680. {
  681.  {3,ch60st0}
  682. };
  683. static const SFG_StrokeChar ch60 = {81.6105f,1,ch60st};
  684. /* char: 0x3d */
  685. static const SFG_StrokeVertex ch61st0[] =
  686. {
  687.  {5.7f,57.1429f},
  688.  {91.4143f,57.1429f}
  689. };
  690. static const SFG_StrokeVertex ch61st1[] =
  691. {
  692.  {5.7f,28.5714f},
  693.  {91.4143f,28.5714f}
  694. };
  695. static const SFG_StrokeStrip ch61st[] =
  696. {
  697.  {2,ch61st0},
  698.  {2,ch61st1}
  699. };
  700. static const SFG_StrokeChar ch61 = {97.2543f,2,ch61st};
  701. /* char: 0x3e */
  702. static const SFG_StrokeVertex ch62st0[] =
  703. {
  704.  {2.78f,85.7143f},
  705.  {78.9705f,42.8571f},
  706.  {2.78f,0.0f}
  707. };
  708. static const SFG_StrokeStrip ch62st[] =
  709. {
  710.  {3,ch62st0}
  711. };
  712. static const SFG_StrokeChar ch62 = {81.6105f,1,ch62st};
  713. /* char: 0x3f */
  714. static const SFG_StrokeVertex ch63st0[] =
  715. {
  716.  {8.42f,76.1905f},
  717.  {8.42f,80.9524f},
  718.  {13.1819f,90.4762f},
  719.  {17.9438f,95.2381f},
  720.  {27.4676f,100.0f},
  721.  {46.5152f,100.0f},
  722.  {56.039f,95.2381f},
  723.  {60.801f,90.4762f},
  724.  {65.5629f,80.9524f},
  725.  {65.5629f,71.4286f},
  726.  {60.801f,61.9048f},
  727.  {56.039f,57.1429f},
  728.  {36.9914f,47.619f},
  729.  {36.9914f,33.3333f}
  730. };
  731. static const SFG_StrokeVertex ch63st1[] =
  732. {
  733.  {36.9914f,9.5238f},
  734.  {32.2295f,4.7619f},
  735.  {36.9914f,0.0f},
  736.  {41.7533f,4.7619f},
  737.  {36.9914f,9.5238f}
  738. };
  739. static const SFG_StrokeStrip ch63st[] =
  740. {
  741.  {14,ch63st0},
  742.  {5,ch63st1}
  743. };
  744. static const SFG_StrokeChar ch63 = {73.9029f,2,ch63st};
  745. /* char: 0x40 */
  746. static const SFG_StrokeVertex ch64st0[] =
  747. {
  748.  {49.2171f,52.381f},
  749.  {39.6933f,57.1429f},
  750.  {30.1695f,57.1429f},
  751.  {25.4076f,47.619f},
  752.  {25.4076f,42.8571f},
  753.  {30.1695f,33.3333f},
  754.  {39.6933f,33.3333f},
  755.  {49.2171f,38.0952f}
  756. };
  757. static const SFG_StrokeVertex ch64st1[] =
  758. {
  759.  {49.2171f,57.1429f},
  760.  {49.2171f,38.0952f},
  761.  {53.979f,33.3333f},
  762.  {63.5029f,33.3333f},
  763.  {68.2648f,42.8571f},
  764.  {68.2648f,47.619f},
  765.  {63.5029f,61.9048f},
  766.  {53.979f,71.4286f},
  767.  {39.6933f,76.1905f},
  768.  {34.9314f,76.1905f},
  769.  {20.6457f,71.4286f},
  770.  {11.1219f,61.9048f},
  771.  {6.36f,47.619f},
  772.  {6.36f,42.8571f},
  773.  {11.1219f,28.5714f},
  774.  {20.6457f,19.0476f},
  775.  {34.9314f,14.2857f},
  776.  {39.6933f,14.2857f},
  777.  {53.979f,19.0476f}
  778. };
  779. static const SFG_StrokeStrip ch64st[] =
  780. {
  781.  {8,ch64st0},
  782.  {19,ch64st1}
  783. };
  784. static const SFG_StrokeChar ch64 = {74.3648f,2,ch64st};
  785. /* char: 0x41 */
  786. static const SFG_StrokeVertex ch65st0[] =
  787. {
  788.  {40.5952f,100.0f},
  789.  {2.5f,0.0f}
  790. };
  791. static const SFG_StrokeVertex ch65st1[] =
  792. {
  793.  {40.5952f,100.0f},
  794.  {78.6905f,0.0f}
  795. };
  796. static const SFG_StrokeVertex ch65st2[] =
  797. {
  798.  {16.7857f,33.3333f},
  799.  {64.4048f,33.3333f}
  800. };
  801. static const SFG_StrokeStrip ch65st[] =
  802. {
  803.  {2,ch65st0},
  804.  {2,ch65st1},
  805.  {2,ch65st2}
  806. };
  807. static const SFG_StrokeChar ch65 = {80.4905f,3,ch65st};
  808. /* char: 0x42 */
  809. static const SFG_StrokeVertex ch66st0[] =
  810. {
  811.  {11.42f,100.0f},
  812.  {11.42f,0.0f}
  813. };
  814. static const SFG_StrokeVertex ch66st1[] =
  815. {
  816.  {11.42f,100.0f},
  817.  {54.2771f,100.0f},
  818.  {68.5629f,95.2381f},
  819.  {73.3248f,90.4762f},
  820.  {78.0867f,80.9524f},
  821.  {78.0867f,71.4286f},
  822.  {73.3248f,61.9048f},
  823.  {68.5629f,57.1429f},
  824.  {54.2771f,52.381f}
  825. };
  826. static const SFG_StrokeVertex ch66st2[] =
  827. {
  828.  {11.42f,52.381f},
  829.  {54.2771f,52.381f},
  830.  {68.5629f,47.619f},
  831.  {73.3248f,42.8571f},
  832.  {78.0867f,33.3333f},
  833.  {78.0867f,19.0476f},
  834.  {73.3248f,9.5238f},
  835.  {68.5629f,4.7619f},
  836.  {54.2771f,0.0f},
  837.  {11.42f,0.0f}
  838. };
  839. static const SFG_StrokeStrip ch66st[] =
  840. {
  841.  {2,ch66st0},
  842.  {9,ch66st1},
  843.  {10,ch66st2}
  844. };
  845. static const SFG_StrokeChar ch66 = {83.6267f,3,ch66st};
  846. /* char: 0x43 */
  847. static const SFG_StrokeVertex ch67st0[] =
  848. {
  849.  {78.0886f,76.1905f},
  850.  {73.3267f,85.7143f},
  851.  {63.8029f,95.2381f},
  852.  {54.279f,100.0f},
  853.  {35.2314f,100.0f},
  854.  {25.7076f,95.2381f},
  855.  {16.1838f,85.7143f},
  856.  {11.4219f,76.1905f},
  857.  {6.66f,61.9048f},
  858.  {6.66f,38.0952f},
  859.  {11.4219f,23.8095f},
  860.  {16.1838f,14.2857f},
  861.  {25.7076f,4.7619f},
  862.  {35.2314f,0.0f},
  863.  {54.279f,0.0f},
  864.  {63.8029f,4.7619f},
  865.  {73.3267f,14.2857f},
  866.  {78.0886f,23.8095f}
  867. };
  868. static const SFG_StrokeStrip ch67st[] =
  869. {
  870.  {18,ch67st0}
  871. };
  872. static const SFG_StrokeChar ch67 = {84.4886f,1,ch67st};
  873. /* char: 0x44 */
  874. static const SFG_StrokeVertex ch68st0[] =
  875. {
  876.  {11.96f,100.0f},
  877.  {11.96f,0.0f}
  878. };
  879. static const SFG_StrokeVertex ch68st1[] =
  880. {
  881.  {11.96f,100.0f},
  882.  {45.2933f,100.0f},
  883.  {59.579f,95.2381f},
  884.  {69.1029f,85.7143f},
  885.  {73.8648f,76.1905f},
  886.  {78.6267f,61.9048f},
  887.  {78.6267f,38.0952f},
  888.  {73.8648f,23.8095f},
  889.  {69.1029f,14.2857f},
  890.  {59.579f,4.7619f},
  891.  {45.2933f,0.0f},
  892.  {11.96f,0.0f}
  893. };
  894. static const SFG_StrokeStrip ch68st[] =
  895. {
  896.  {2,ch68st0},
  897.  {12,ch68st1}
  898. };
  899. static const SFG_StrokeChar ch68 = {85.2867f,2,ch68st};
  900. /* char: 0x45 */
  901. static const SFG_StrokeVertex ch69st0[] =
  902. {
  903.  {11.42f,100.0f},
  904.  {11.42f,0.0f}
  905. };
  906. static const SFG_StrokeVertex ch69st1[] =
  907. {
  908.  {11.42f,100.0f},
  909.  {73.3248f,100.0f}
  910. };
  911. static const SFG_StrokeVertex ch69st2[] =
  912. {
  913.  {11.42f,52.381f},
  914.  {49.5152f,52.381f}
  915. };
  916. static const SFG_StrokeVertex ch69st3[] =
  917. {
  918.  {11.42f,0.0f},
  919.  {73.3248f,0.0f}
  920. };
  921. static const SFG_StrokeStrip ch69st[] =
  922. {
  923.  {2,ch69st0},
  924.  {2,ch69st1},
  925.  {2,ch69st2},
  926.  {2,ch69st3}
  927. };
  928. static const SFG_StrokeChar ch69 = {78.1848f,4,ch69st};
  929. /* char: 0x46 */
  930. static const SFG_StrokeVertex ch70st0[] =
  931. {
  932.  {11.42f,100.0f},
  933.  {11.42f,0.0f}
  934. };
  935. static const SFG_StrokeVertex ch70st1[] =
  936. {
  937.  {11.42f,100.0f},
  938.  {73.3248f,100.0f}
  939. };
  940. static const SFG_StrokeVertex ch70st2[] =
  941. {
  942.  {11.42f,52.381f},
  943.  {49.5152f,52.381f}
  944. };
  945. static const SFG_StrokeStrip ch70st[] =
  946. {
  947.  {2,ch70st0},
  948.  {2,ch70st1},
  949.  {2,ch70st2}
  950. };
  951. static const SFG_StrokeChar ch70 = {78.7448f,3,ch70st};
  952. /* char: 0x47 */
  953. static const SFG_StrokeVertex ch71st0[] =
  954. {
  955.  {78.4886f,76.1905f},
  956.  {73.7267f,85.7143f},
  957.  {64.2029f,95.2381f},
  958.  {54.679f,100.0f},
  959.  {35.6314f,100.0f},
  960.  {26.1076f,95.2381f},
  961.  {16.5838f,85.7143f},
  962.  {11.8219f,76.1905f},
  963.  {7.06f,61.9048f},
  964.  {7.06f,38.0952f},
  965.  {11.8219f,23.8095f},
  966.  {16.5838f,14.2857f},
  967.  {26.1076f,4.7619f},
  968.  {35.6314f,0.0f},
  969.  {54.679f,0.0f},
  970.  {64.2029f,4.7619f},
  971.  {73.7267f,14.2857f},
  972.  {78.4886f,23.8095f},
  973.  {78.4886f,38.0952f}
  974. };
  975. static const SFG_StrokeVertex ch71st1[] =
  976. {
  977.  {54.679f,38.0952f},
  978.  {78.4886f,38.0952f}
  979. };
  980. static const SFG_StrokeStrip ch71st[] =
  981. {
  982.  {19,ch71st0},
  983.  {2,ch71st1}
  984. };
  985. static const SFG_StrokeChar ch71 = {89.7686f,2,ch71st};
  986. /* char: 0x48 */
  987. static const SFG_StrokeVertex ch72st0[] =
  988. {
  989.  {11.42f,100.0f},
  990.  {11.42f,0.0f}
  991. };
  992. static const SFG_StrokeVertex ch72st1[] =
  993. {
  994.  {78.0867f,100.0f},
  995.  {78.0867f,0.0f}
  996. };
  997. static const SFG_StrokeVertex ch72st2[] =
  998. {
  999.  {11.42f,52.381f},
  1000.  {78.0867f,52.381f}
  1001. };
  1002. static const SFG_StrokeStrip ch72st[] =
  1003. {
  1004.  {2,ch72st0},
  1005.  {2,ch72st1},
  1006.  {2,ch72st2}
  1007. };
  1008. static const SFG_StrokeChar ch72 = {89.0867f,3,ch72st};
  1009. /* char: 0x49 */
  1010. static const SFG_StrokeVertex ch73st0[] =
  1011. {
  1012.  {10.86f,100.0f},
  1013.  {10.86f,0.0f}
  1014. };
  1015. static const SFG_StrokeStrip ch73st[] =
  1016. {
  1017.  {2,ch73st0}
  1018. };
  1019. static const SFG_StrokeChar ch73 = {21.3f,1,ch73st};
  1020. /* char: 0x4a */
  1021. static const SFG_StrokeVertex ch74st0[] =
  1022. {
  1023.  {50.119f,100.0f},
  1024.  {50.119f,23.8095f},
  1025.  {45.3571f,9.5238f},
  1026.  {40.5952f,4.7619f},
  1027.  {31.0714f,0.0f},
  1028.  {21.5476f,0.0f},
  1029.  {12.0238f,4.7619f},
  1030.  {7.2619f,9.5238f},
  1031.  {2.5f,23.8095f},
  1032.  {2.5f,33.3333f}
  1033. };
  1034. static const SFG_StrokeStrip ch74st[] =
  1035. {
  1036.  {10,ch74st0}
  1037. };
  1038. static const SFG_StrokeChar ch74 = {59.999f,1,ch74st};
  1039. /* char: 0x4b */
  1040. static const SFG_StrokeVertex ch75st0[] =
  1041. {
  1042.  {11.28f,100.0f},
  1043.  {11.28f,0.0f}
  1044. };
  1045. static const SFG_StrokeVertex ch75st1[] =
  1046. {
  1047.  {77.9467f,100.0f},
  1048.  {11.28f,33.3333f}
  1049. };
  1050. static const SFG_StrokeVertex ch75st2[] =
  1051. {
  1052.  {35.0895f,57.1429f},
  1053.  {77.9467f,0.0f}
  1054. };
  1055. static const SFG_StrokeStrip ch75st[] =
  1056. {
  1057.  {2,ch75st0},
  1058.  {2,ch75st1},
  1059.  {2,ch75st2}
  1060. };
  1061. static const SFG_StrokeChar ch75 = {79.3267f,3,ch75st};
  1062. /* char: 0x4c */
  1063. static const SFG_StrokeVertex ch76st0[] =
  1064. {
  1065.  {11.68f,100.0f},
  1066.  {11.68f,0.0f}
  1067. };
  1068. static const SFG_StrokeVertex ch76st1[] =
  1069. {
  1070.  {11.68f,0.0f},
  1071.  {68.8229f,0.0f}
  1072. };
  1073. static const SFG_StrokeStrip ch76st[] =
  1074. {
  1075.  {2,ch76st0},
  1076.  {2,ch76st1}
  1077. };
  1078. static const SFG_StrokeChar ch76 = {71.3229f,2,ch76st};
  1079. /* char: 0x4d */
  1080. static const SFG_StrokeVertex ch77st0[] =
  1081. {
  1082.  {10.86f,100.0f},
  1083.  {10.86f,0.0f}
  1084. };
  1085. static const SFG_StrokeVertex ch77st1[] =
  1086. {
  1087.  {10.86f,100.0f},
  1088.  {48.9552f,0.0f}
  1089. };
  1090. static const SFG_StrokeVertex ch77st2[] =
  1091. {
  1092.  {87.0505f,100.0f},
  1093.  {48.9552f,0.0f}
  1094. };
  1095. static const SFG_StrokeVertex ch77st3[] =
  1096. {
  1097.  {87.0505f,100.0f},
  1098.  {87.0505f,0.0f}
  1099. };
  1100. static const SFG_StrokeStrip ch77st[] =
  1101. {
  1102.  {2,ch77st0},
  1103.  {2,ch77st1},
  1104.  {2,ch77st2},
  1105.  {2,ch77st3}
  1106. };
  1107. static const SFG_StrokeChar ch77 = {97.2105f,4,ch77st};
  1108. /* char: 0x4e */
  1109. static const SFG_StrokeVertex ch78st0[] =
  1110. {
  1111.  {11.14f,100.0f},
  1112.  {11.14f,0.0f}
  1113. };
  1114. static const SFG_StrokeVertex ch78st1[] =
  1115. {
  1116.  {11.14f,100.0f},
  1117.  {77.8067f,0.0f}
  1118. };
  1119. static const SFG_StrokeVertex ch78st2[] =
  1120. {
  1121.  {77.8067f,100.0f},
  1122.  {77.8067f,0.0f}
  1123. };
  1124. static const SFG_StrokeStrip ch78st[] =
  1125. {
  1126.  {2,ch78st0},
  1127.  {2,ch78st1},
  1128.  {2,ch78st2}
  1129. };
  1130. static const SFG_StrokeChar ch78 = {88.8067f,3,ch78st};
  1131. /* char: 0x4f */
  1132. static const SFG_StrokeVertex ch79st0[] =
  1133. {
  1134.  {34.8114f,100.0f},
  1135.  {25.2876f,95.2381f},
  1136.  {15.7638f,85.7143f},
  1137.  {11.0019f,76.1905f},
  1138.  {6.24f,61.9048f},
  1139.  {6.24f,38.0952f},
  1140.  {11.0019f,23.8095f},
  1141.  {15.7638f,14.2857f},
  1142.  {25.2876f,4.7619f},
  1143.  {34.8114f,0.0f},
  1144.  {53.859f,0.0f},
  1145.  {63.3829f,4.7619f},
  1146.  {72.9067f,14.2857f},
  1147.  {77.6686f,23.8095f},
  1148.  {82.4305f,38.0952f},
  1149.  {82.4305f,61.9048f},
  1150.  {77.6686f,76.1905f},
  1151.  {72.9067f,85.7143f},
  1152.  {63.3829f,95.2381f},
  1153.  {53.859f,100.0f},
  1154.  {34.8114f,100.0f}
  1155. };
  1156. static const SFG_StrokeStrip ch79st[] =
  1157. {
  1158.  {21,ch79st0}
  1159. };
  1160. static const SFG_StrokeChar ch79 = {88.8305f,1,ch79st};
  1161. /* char: 0x50 */
  1162. static const SFG_StrokeVertex ch80st0[] =
  1163. {
  1164.  {12.1f,100.0f},
  1165.  {12.1f,0.0f}
  1166. };
  1167. static const SFG_StrokeVertex ch80st1[] =
  1168. {
  1169.  {12.1f,100.0f},
  1170.  {54.9571f,100.0f},
  1171.  {69.2429f,95.2381f},
  1172.  {74.0048f,90.4762f},
  1173.  {78.7667f,80.9524f},
  1174.  {78.7667f,66.6667f},
  1175.  {74.0048f,57.1429f},
  1176.  {69.2429f,52.381f},
  1177.  {54.9571f,47.619f},
  1178.  {12.1f,47.619f}
  1179. };
  1180. static const SFG_StrokeStrip ch80st[] =
  1181. {
  1182.  {2,ch80st0},
  1183.  {10,ch80st1}
  1184. };
  1185. static const SFG_StrokeChar ch80 = {85.6667f,2,ch80st};
  1186. /* char: 0x51 */
  1187. static const SFG_StrokeVertex ch81st0[] =
  1188. {
  1189.  {33.8714f,100.0f},
  1190.  {24.3476f,95.2381f},
  1191.  {14.8238f,85.7143f},
  1192.  {10.0619f,76.1905f},
  1193.  {5.3f,61.9048f},
  1194.  {5.3f,38.0952f},
  1195.  {10.0619f,23.8095f},
  1196.  {14.8238f,14.2857f},
  1197.  {24.3476f,4.7619f},
  1198.  {33.8714f,0.0f},
  1199.  {52.919f,0.0f},
  1200.  {62.4429f,4.7619f},
  1201.  {71.9667f,14.2857f},
  1202.  {76.7286f,23.8095f},
  1203.  {81.4905f,38.0952f},
  1204.  {81.4905f,61.9048f},
  1205.  {76.7286f,76.1905f},
  1206.  {71.9667f,85.7143f},
  1207.  {62.4429f,95.2381f},
  1208.  {52.919f,100.0f},
  1209.  {33.8714f,100.0f}
  1210. };
  1211. static const SFG_StrokeVertex ch81st1[] =
  1212. {
  1213.  {48.1571f,19.0476f},
  1214.  {76.7286f,-9.5238f}
  1215. };
  1216. static const SFG_StrokeStrip ch81st[] =
  1217. {
  1218.  {21,ch81st0},
  1219.  {2,ch81st1}
  1220. };
  1221. static const SFG_StrokeChar ch81 = {88.0905f,2,ch81st};
  1222. /* char: 0x52 */
  1223. static const SFG_StrokeVertex ch82st0[] =
  1224. {
  1225.  {11.68f,100.0f},
  1226.  {11.68f,0.0f}
  1227. };
  1228. static const SFG_StrokeVertex ch82st1[] =
  1229. {
  1230.  {11.68f,100.0f},
  1231.  {54.5371f,100.0f},
  1232.  {68.8229f,95.2381f},
  1233.  {73.5848f,90.4762f},
  1234.  {78.3467f,80.9524f},
  1235.  {78.3467f,71.4286f},
  1236.  {73.5848f,61.9048f},
  1237.  {68.8229f,57.1429f},
  1238.  {54.5371f,52.381f},
  1239.  {11.68f,52.381f}
  1240. };
  1241. static const SFG_StrokeVertex ch82st2[] =
  1242. {
  1243.  {45.0133f,52.381f},
  1244.  {78.3467f,0.0f}
  1245. };
  1246. static const SFG_StrokeStrip ch82st[] =
  1247. {
  1248.  {2,ch82st0},
  1249.  {10,ch82st1},
  1250.  {2,ch82st2}
  1251. };
  1252. static const SFG_StrokeChar ch82 = {82.3667f,3,ch82st};
  1253. /* char: 0x53 */
  1254. static const SFG_StrokeVertex ch83st0[] =
  1255. {
  1256.  {74.6667f,85.7143f},
  1257.  {65.1429f,95.2381f},
  1258.  {50.8571f,100.0f},
  1259.  {31.8095f,100.0f},
  1260.  {17.5238f,95.2381f},
  1261.  {8.0f,85.7143f},
  1262.  {8.0f,76.1905f},
  1263.  {12.7619f,66.6667f},
  1264.  {17.5238f,61.9048f},
  1265.  {27.0476f,57.1429f},
  1266.  {55.619f,47.619f},
  1267.  {65.1429f,42.8571f},
  1268.  {69.9048f,38.0952f},
  1269.  {74.6667f,28.5714f},
  1270.  {74.6667f,14.2857f},
  1271.  {65.1429f,4.7619f},
  1272.  {50.8571f,0.0f},
  1273.  {31.8095f,0.0f},
  1274.  {17.5238f,4.7619f},
  1275.  {8.0f,14.2857f}
  1276. };
  1277. static const SFG_StrokeStrip ch83st[] =
  1278. {
  1279.  {20,ch83st0}
  1280. };
  1281. static const SFG_StrokeChar ch83 = {80.8267f,1,ch83st};
  1282. /* char: 0x54 */
  1283. static const SFG_StrokeVertex ch84st0[] =
  1284. {
  1285.  {35.6933f,100.0f},
  1286.  {35.6933f,0.0f}
  1287. };
  1288. static const SFG_StrokeVertex ch84st1[] =
  1289. {
  1290.  {2.36f,100.0f},
  1291.  {69.0267f,100.0f}
  1292. };
  1293. static const SFG_StrokeStrip ch84st[] =
  1294. {
  1295.  {2,ch84st0},
  1296.  {2,ch84st1}
  1297. };
  1298. static const SFG_StrokeChar ch84 = {71.9467f,2,ch84st};
  1299. /* char: 0x55 */
  1300. static const SFG_StrokeVertex ch85st0[] =
  1301. {
  1302.  {11.54f,100.0f},
  1303.  {11.54f,28.5714f},
  1304.  {16.3019f,14.2857f},
  1305.  {25.8257f,4.7619f},
  1306.  {40.1114f,0.0f},
  1307.  {49.6352f,0.0f},
  1308.  {63.921f,4.7619f},
  1309.  {73.4448f,14.2857f},
  1310.  {78.2067f,28.5714f},
  1311.  {78.2067f,100.0f}
  1312. };
  1313. static const SFG_StrokeStrip ch85st[] =
  1314. {
  1315.  {10,ch85st0}
  1316. };
  1317. static const SFG_StrokeChar ch85 = {89.4867f,1,ch85st};
  1318. /* char: 0x56 */
  1319. static const SFG_StrokeVertex ch86st0[] =
  1320. {
  1321.  {2.36f,100.0f},
  1322.  {40.4552f,0.0f}
  1323. };
  1324. static const SFG_StrokeVertex ch86st1[] =
  1325. {
  1326.  {78.5505f,100.0f},
  1327.  {40.4552f,0.0f}
  1328. };
  1329. static const SFG_StrokeStrip ch86st[] =
  1330. {
  1331.  {2,ch86st0},
  1332.  {2,ch86st1}
  1333. };
  1334. static const SFG_StrokeChar ch86 = {81.6105f,2,ch86st};
  1335. /* char: 0x57 */
  1336. static const SFG_StrokeVertex ch87st0[] =
  1337. {
  1338.  {2.22f,100.0f},
  1339.  {26.0295f,0.0f}
  1340. };
  1341. static const SFG_StrokeVertex ch87st1[] =
  1342. {
  1343.  {49.839f,100.0f},
  1344.  {26.0295f,0.0f}
  1345. };
  1346. static const SFG_StrokeVertex ch87st2[] =
  1347. {
  1348.  {49.839f,100.0f},
  1349.  {73.6486f,0.0f}
  1350. };
  1351. static const SFG_StrokeVertex ch87st3[] =
  1352. {
  1353.  {97.4581f,100.0f},
  1354.  {73.6486f,0.0f}
  1355. };
  1356. static const SFG_StrokeStrip ch87st[] =
  1357. {
  1358.  {2,ch87st0},
  1359.  {2,ch87st1},
  1360.  {2,ch87st2},
  1361.  {2,ch87st3}
  1362. };
  1363. static const SFG_StrokeChar ch87 = {100.518f,4,ch87st};
  1364. /* char: 0x58 */
  1365. static const SFG_StrokeVertex ch88st0[] =
  1366. {
  1367.  {2.5f,100.0f},
  1368.  {69.1667f,0.0f}
  1369. };
  1370. static const SFG_StrokeVertex ch88st1[] =
  1371. {
  1372.  {69.1667f,100.0f},
  1373.  {2.5f,0.0f}
  1374. };
  1375. static const SFG_StrokeStrip ch88st[] =
  1376. {
  1377.  {2,ch88st0},
  1378.  {2,ch88st1}
  1379. };
  1380. static const SFG_StrokeChar ch88 = {72.3667f,2,ch88st};
  1381. /* char: 0x59 */
  1382. static const SFG_StrokeVertex ch89st0[] =
  1383. {
  1384.  {1.52f,100.0f},
  1385.  {39.6152f,52.381f},
  1386.  {39.6152f,0.0f}
  1387. };
  1388. static const SFG_StrokeVertex ch89st1[] =
  1389. {
  1390.  {77.7105f,100.0f},
  1391.  {39.6152f,52.381f}
  1392. };
  1393. static const SFG_StrokeStrip ch89st[] =
  1394. {
  1395.  {3,ch89st0},
  1396.  {2,ch89st1}
  1397. };
  1398. static const SFG_StrokeChar ch89 = {79.6505f,2,ch89st};
  1399. /* char: 0x5a */
  1400. static const SFG_StrokeVertex ch90st0[] =
  1401. {
  1402.  {69.1667f,100.0f},
  1403.  {2.5f,0.0f}
  1404. };
  1405. static const SFG_StrokeVertex ch90st1[] =
  1406. {
  1407.  {2.5f,100.0f},
  1408.  {69.1667f,100.0f}
  1409. };
  1410. static const SFG_StrokeVertex ch90st2[] =
  1411. {
  1412.  {2.5f,0.0f},
  1413.  {69.1667f,0.0f}
  1414. };
  1415. static const SFG_StrokeStrip ch90st[] =
  1416. {
  1417.  {2,ch90st0},
  1418.  {2,ch90st1},
  1419.  {2,ch90st2}
  1420. };
  1421. static const SFG_StrokeChar ch90 = {73.7467f,3,ch90st};
  1422. /* char: 0x5b */
  1423. static const SFG_StrokeVertex ch91st0[] =
  1424. {
  1425.  {7.78f,119.048f},
  1426.  {7.78f,-33.3333f}
  1427. };
  1428. static const SFG_StrokeVertex ch91st1[] =
  1429. {
  1430.  {12.5419f,119.048f},
  1431.  {12.5419f,-33.3333f}
  1432. };
  1433. static const SFG_StrokeVertex ch91st2[] =
  1434. {
  1435.  {7.78f,119.048f},
  1436.  {41.1133f,119.048f}
  1437. };
  1438. static const SFG_StrokeVertex ch91st3[] =
  1439. {
  1440.  {7.78f,-33.3333f},
  1441.  {41.1133f,-33.3333f}
  1442. };
  1443. static const SFG_StrokeStrip ch91st[] =
  1444. {
  1445.  {2,ch91st0},
  1446.  {2,ch91st1},
  1447.  {2,ch91st2},
  1448.  {2,ch91st3}
  1449. };
  1450. static const SFG_StrokeChar ch91 = {46.1133f,4,ch91st};
  1451. /* char: 0x5c */
  1452. static const SFG_StrokeVertex ch92st0[] =
  1453. {
  1454.  {5.84f,100.0f},
  1455.  {72.5067f,-14.2857f}
  1456. };
  1457. static const SFG_StrokeStrip ch92st[] =
  1458. {
  1459.  {2,ch92st0}
  1460. };
  1461. static const SFG_StrokeChar ch92 = {78.2067f,1,ch92st};
  1462. /* char: 0x5d */
  1463. static const SFG_StrokeVertex ch93st0[] =
  1464. {
  1465.  {33.0114f,119.048f},
  1466.  {33.0114f,-33.3333f}
  1467. };
  1468. static const SFG_StrokeVertex ch93st1[] =
  1469. {
  1470.  {37.7733f,119.048f},
  1471.  {37.7733f,-33.3333f}
  1472. };
  1473. static const SFG_StrokeVertex ch93st2[] =
  1474. {
  1475.  {4.44f,119.048f},
  1476.  {37.7733f,119.048f}
  1477. };
  1478. static const SFG_StrokeVertex ch93st3[] =
  1479. {
  1480.  {4.44f,-33.3333f},
  1481.  {37.7733f,-33.3333f}
  1482. };
  1483. static const SFG_StrokeStrip ch93st[] =
  1484. {
  1485.  {2,ch93st0},
  1486.  {2,ch93st1},
  1487.  {2,ch93st2},
  1488.  {2,ch93st3}
  1489. };
  1490. static const SFG_StrokeChar ch93 = {46.3933f,4,ch93st};
  1491. /* char: 0x5e */
  1492. static const SFG_StrokeVertex ch94st0[] =
  1493. {
  1494.  {44.0752f,109.524f},
  1495.  {5.98f,42.8571f}
  1496. };
  1497. static const SFG_StrokeVertex ch94st1[] =
  1498. {
  1499.  {44.0752f,109.524f},
  1500.  {82.1705f,42.8571f}
  1501. };
  1502. static const SFG_StrokeStrip ch94st[] =
  1503. {
  1504.  {2,ch94st0},
  1505.  {2,ch94st1}
  1506. };
  1507. static const SFG_StrokeChar ch94 = {90.2305f,2,ch94st};
  1508. /* char: 0x5f */
  1509. static const SFG_StrokeVertex ch95st0[] =
  1510. {
  1511.  {-1.1f,-33.3333f},
  1512.  {103.662f,-33.3333f},
  1513.  {103.662f,-28.5714f},
  1514.  {-1.1f,-28.5714f},
  1515.  {-1.1f,-33.3333f}
  1516. };
  1517. static const SFG_StrokeStrip ch95st[] =
  1518. {
  1519.  {5,ch95st0}
  1520. };
  1521. static const SFG_StrokeChar ch95 = {104.062f,1,ch95st};
  1522. /* char: 0x60 */
  1523. static const SFG_StrokeVertex ch96st0[] =
  1524. {
  1525.  {33.0219f,100.0f},
  1526.  {56.8314f,71.4286f}
  1527. };
  1528. static const SFG_StrokeVertex ch96st1[] =
  1529. {
  1530.  {33.0219f,100.0f},
  1531.  {28.26f,95.2381f},
  1532.  {56.8314f,71.4286f}
  1533. };
  1534. static const SFG_StrokeStrip ch96st[] =
  1535. {
  1536.  {2,ch96st0},
  1537.  {3,ch96st1}
  1538. };
  1539. static const SFG_StrokeChar ch96 = {83.5714f,2,ch96st};
  1540. /* char: 0x61 */
  1541. static const SFG_StrokeVertex ch97st0[] =
  1542. {
  1543.  {63.8229f,66.6667f},
  1544.  {63.8229f,0.0f}
  1545. };
  1546. static const SFG_StrokeVertex ch97st1[] =
  1547. {
  1548.  {63.8229f,52.381f},
  1549.  {54.299f,61.9048f},
  1550.  {44.7752f,66.6667f},
  1551.  {30.4895f,66.6667f},
  1552.  {20.9657f,61.9048f},
  1553.  {11.4419f,52.381f},
  1554.  {6.68f,38.0952f},
  1555.  {6.68f,28.5714f},
  1556.  {11.4419f,14.2857f},
  1557.  {20.9657f,4.7619f},
  1558.  {30.4895f,0.0f},
  1559.  {44.7752f,0.0f},
  1560.  {54.299f,4.7619f},
  1561.  {63.8229f,14.2857f}
  1562. };
  1563. static const SFG_StrokeStrip ch97st[] =
  1564. {
  1565.  {2,ch97st0},
  1566.  {14,ch97st1}
  1567. };
  1568. static const SFG_StrokeChar ch97 = {66.6029f,2,ch97st};
  1569. /* char: 0x62 */
  1570. static const SFG_StrokeVertex ch98st0[] =
  1571. {
  1572.  {8.76f,100.0f},
  1573.  {8.76f,0.0f}
  1574. };
  1575. static const SFG_StrokeVertex ch98st1[] =
  1576. {
  1577.  {8.76f,52.381f},
  1578.  {18.2838f,61.9048f},
  1579.  {27.8076f,66.6667f},
  1580.  {42.0933f,66.6667f},
  1581.  {51.6171f,61.9048f},
  1582.  {61.141f,52.381f},
  1583.  {65.9029f,38.0952f},
  1584.  {65.9029f,28.5714f},
  1585.  {61.141f,14.2857f},
  1586.  {51.6171f,4.7619f},
  1587.  {42.0933f,0.0f},
  1588.  {27.8076f,0.0f},
  1589.  {18.2838f,4.7619f},
  1590.  {8.76f,14.2857f}
  1591. };
  1592. static const SFG_StrokeStrip ch98st[] =
  1593. {
  1594.  {2,ch98st0},
  1595.  {14,ch98st1}
  1596. };
  1597. static const SFG_StrokeChar ch98 = {70.4629f,2,ch98st};
  1598. /* char: 0x63 */
  1599. static const SFG_StrokeVertex ch99st0[] =
  1600. {
  1601.  {62.6629f,52.381f},
  1602.  {53.139f,61.9048f},
  1603.  {43.6152f,66.6667f},
  1604.  {29.3295f,66.6667f},
  1605.  {19.8057f,61.9048f},
  1606.  {10.2819f,52.381f},
  1607.  {5.52f,38.0952f},
  1608.  {5.52f,28.5714f},
  1609.  {10.2819f,14.2857f},
  1610.  {19.8057f,4.7619f},
  1611.  {29.3295f,0.0f},
  1612.  {43.6152f,0.0f},
  1613.  {53.139f,4.7619f},
  1614.  {62.6629f,14.2857f}
  1615. };
  1616. static const SFG_StrokeStrip ch99st[] =
  1617. {
  1618.  {14,ch99st0}
  1619. };
  1620. static const SFG_StrokeChar ch99 = {68.9229f,1,ch99st};
  1621. /* char: 0x64 */
  1622. static const SFG_StrokeVertex ch100st0[] =
  1623. {
  1624.  {61.7829f,100.0f},
  1625.  {61.7829f,0.0f}
  1626. };
  1627. static const SFG_StrokeVertex ch100st1[] =
  1628. {
  1629.  {61.7829f,52.381f},
  1630.  {52.259f,61.9048f},
  1631.  {42.7352f,66.6667f},
  1632.  {28.4495f,66.6667f},
  1633.  {18.9257f,61.9048f},
  1634.  {9.4019f,52.381f},
  1635.  {4.64f,38.0952f},
  1636.  {4.64f,28.5714f},
  1637.  {9.4019f,14.2857f},
  1638.  {18.9257f,4.7619f},
  1639.  {28.4495f,0.0f},
  1640.  {42.7352f,0.0f},
  1641.  {52.259f,4.7619f},
  1642.  {61.7829f,14.2857f}
  1643. };
  1644. static const SFG_StrokeStrip ch100st[] =
  1645. {
  1646.  {2,ch100st0},
  1647.  {14,ch100st1}
  1648. };
  1649. static const SFG_StrokeChar ch100 = {70.2629f,2,ch100st};
  1650. /* char: 0x65 */
  1651. static const SFG_StrokeVertex ch101st0[] =
  1652. {
  1653.  {5.72f,38.0952f},
  1654.  {62.8629f,38.0952f},
  1655.  {62.8629f,47.619f},
  1656.  {58.101f,57.1429f},
  1657.  {53.339f,61.9048f},
  1658.  {43.8152f,66.6667f},
  1659.  {29.5295f,66.6667f},
  1660.  {20.0057f,61.9048f},
  1661.  {10.4819f,52.381f},
  1662.  {5.72f,38.0952f},
  1663.  {5.72f,28.5714f},
  1664.  {10.4819f,14.2857f},
  1665.  {20.0057f,4.7619f},
  1666.  {29.5295f,0.0f},
  1667.  {43.8152f,0.0f},
  1668.  {53.339f,4.7619f},
  1669.  {62.8629f,14.2857f}
  1670. };
  1671. static const SFG_StrokeStrip ch101st[] =
  1672. {
  1673.  {17,ch101st0}
  1674. };
  1675. static const SFG_StrokeChar ch101 = {68.5229f,1,ch101st};
  1676. /* char: 0x66 */
  1677. static const SFG_StrokeVertex ch102st0[] =
  1678. {
  1679.  {38.7752f,100.0f},
  1680.  {29.2514f,100.0f},
  1681.  {19.7276f,95.2381f},
  1682.  {14.9657f,80.9524f},
  1683.  {14.9657f,0.0f}
  1684. };
  1685. static const SFG_StrokeVertex ch102st1[] =
  1686. {
  1687.  {0.68f,66.6667f},
  1688.  {34.0133f,66.6667f}
  1689. };
  1690. static const SFG_StrokeStrip ch102st[] =
  1691. {
  1692.  {5,ch102st0},
  1693.  {2,ch102st1}
  1694. };
  1695. static const SFG_StrokeChar ch102 = {38.6552f,2,ch102st};
  1696. /* char: 0x67 */
  1697. static const SFG_StrokeVertex ch103st0[] =
  1698. {
  1699.  {62.5029f,66.6667f},
  1700.  {62.5029f,-9.5238f},
  1701.  {57.741f,-23.8095f},
  1702.  {52.979f,-28.5714f},
  1703.  {43.4552f,-33.3333f},
  1704.  {29.1695f,-33.3333f},
  1705.  {19.6457f,-28.5714f}
  1706. };
  1707. static const SFG_StrokeVertex ch103st1[] =
  1708. {
  1709.  {62.5029f,52.381f},
  1710.  {52.979f,61.9048f},
  1711.  {43.4552f,66.6667f},
  1712.  {29.1695f,66.6667f},
  1713.  {19.6457f,61.9048f},
  1714.  {10.1219f,52.381f},
  1715.  {5.36f,38.0952f},
  1716.  {5.36f,28.5714f},
  1717.  {10.1219f,14.2857f},
  1718.  {19.6457f,4.7619f},
  1719.  {29.1695f,0.0f},
  1720.  {43.4552f,0.0f},
  1721.  {52.979f,4.7619f},
  1722.  {62.5029f,14.2857f}
  1723. };
  1724. static const SFG_StrokeStrip ch103st[] =
  1725. {
  1726.  {7,ch103st0},
  1727.  {14,ch103st1}
  1728. };
  1729. static const SFG_StrokeChar ch103 = {70.9829f,2,ch103st};
  1730. /* char: 0x68 */
  1731. static const SFG_StrokeVertex ch104st0[] =
  1732. {
  1733.  {9.6f,100.0f},
  1734.  {9.6f,0.0f}
  1735. };
  1736. static const SFG_StrokeVertex ch104st1[] =
  1737. {
  1738.  {9.6f,47.619f},
  1739.  {23.8857f,61.9048f},
  1740.  {33.4095f,66.6667f},
  1741.  {47.6952f,66.6667f},
  1742.  {57.219f,61.9048f},
  1743.  {61.981f,47.619f},
  1744.  {61.981f,0.0f}
  1745. };
  1746. static const SFG_StrokeStrip ch104st[] =
  1747. {
  1748.  {2,ch104st0},
  1749.  {7,ch104st1}
  1750. };
  1751. static const SFG_StrokeChar ch104 = {71.021f,2,ch104st};
  1752. /* char: 0x69 */
  1753. static const SFG_StrokeVertex ch105st0[] =
  1754. {
  1755.  {10.02f,100.0f},
  1756.  {14.7819f,95.2381f},
  1757.  {19.5438f,100.0f},
  1758.  {14.7819f,104.762f},
  1759.  {10.02f,100.0f}
  1760. };
  1761. static const SFG_StrokeVertex ch105st1[] =
  1762. {
  1763.  {14.7819f,66.6667f},
  1764.  {14.7819f,0.0f}
  1765. };
  1766. static const SFG_StrokeStrip ch105st[] =
  1767. {
  1768.  {5,ch105st0},
  1769.  {2,ch105st1}
  1770. };
  1771. static const SFG_StrokeChar ch105 = {28.8638f,2,ch105st};
  1772. /* char: 0x6a */
  1773. static const SFG_StrokeVertex ch106st0[] =
  1774. {
  1775.  {17.3876f,100.0f},
  1776.  {22.1495f,95.2381f},
  1777.  {26.9114f,100.0f},
  1778.  {22.1495f,104.762f},
  1779.  {17.3876f,100.0f}
  1780. };
  1781. static const SFG_StrokeVertex ch106st1[] =
  1782. {
  1783.  {22.1495f,66.6667f},
  1784.  {22.1495f,-14.2857f},
  1785.  {17.3876f,-28.5714f},
  1786.  {7.8638f,-33.3333f},
  1787.  {-1.66f,-33.3333f}
  1788. };
  1789. static const SFG_StrokeStrip ch106st[] =
  1790. {
  1791.  {5,ch106st0},
  1792.  {5,ch106st1}
  1793. };
  1794. static const SFG_StrokeChar ch106 = {36.2314f,2,ch106st};
  1795. /* char: 0x6b */
  1796. static const SFG_StrokeVertex ch107st0[] =
  1797. {
  1798.  {9.6f,100.0f},
  1799.  {9.6f,0.0f}
  1800. };
  1801. static const SFG_StrokeVertex ch107st1[] =
  1802. {
  1803.  {57.219f,66.6667f},
  1804.  {9.6f,19.0476f}
  1805. };
  1806. static const SFG_StrokeVertex ch107st2[] =
  1807. {
  1808.  {28.6476f,38.0952f},
  1809.  {61.981f,0.0f}
  1810. };
  1811. static const SFG_StrokeStrip ch107st[] =
  1812. {
  1813.  {2,ch107st0},
  1814.  {2,ch107st1},
  1815.  {2,ch107st2}
  1816. };
  1817. static const SFG_StrokeChar ch107 = {62.521f,3,ch107st};
  1818. /* char: 0x6c */
  1819. static const SFG_StrokeVertex ch108st0[] =
  1820. {
  1821.  {10.02f,100.0f},
  1822.  {10.02f,0.0f}
  1823. };
  1824. static const SFG_StrokeStrip ch108st[] =
  1825. {
  1826.  {2,ch108st0}
  1827. };
  1828. static const SFG_StrokeChar ch108 = {19.34f,1,ch108st};
  1829. /* char: 0x6d */
  1830. static const SFG_StrokeVertex ch109st0[] =
  1831. {
  1832.  {9.6f,66.6667f},
  1833.  {9.6f,0.0f}
  1834. };
  1835. static const SFG_StrokeVertex ch109st1[] =
  1836. {
  1837.  {9.6f,47.619f},
  1838.  {23.8857f,61.9048f},
  1839.  {33.4095f,66.6667f},
  1840.  {47.6952f,66.6667f},
  1841.  {57.219f,61.9048f},
  1842.  {61.981f,47.619f},
  1843.  {61.981f,0.0f}
  1844. };
  1845. static const SFG_StrokeVertex ch109st2[] =
  1846. {
  1847.  {61.981f,47.619f},
  1848.  {76.2667f,61.9048f},
  1849.  {85.7905f,66.6667f},
  1850.  {100.076f,66.6667f},
  1851.  {109.6f,61.9048f},
  1852.  {114.362f,47.619f},
  1853.  {114.362f,0.0f}
  1854. };
  1855. static const SFG_StrokeStrip ch109st[] =
  1856. {
  1857.  {2,ch109st0},
  1858.  {7,ch109st1},
  1859.  {7,ch109st2}
  1860. };
  1861. static const SFG_StrokeChar ch109 = {123.962f,3,ch109st};
  1862. /* char: 0x6e */
  1863. static const SFG_StrokeVertex ch110st0[] =
  1864. {
  1865.  {9.18f,66.6667f},
  1866.  {9.18f,0.0f}
  1867. };
  1868. static const SFG_StrokeVertex ch110st1[] =
  1869. {
  1870.  {9.18f,47.619f},
  1871.  {23.4657f,61.9048f},
  1872.  {32.9895f,66.6667f},
  1873.  {47.2752f,66.6667f},
  1874.  {56.799f,61.9048f},
  1875.  {61.561f,47.619f},
  1876.  {61.561f,0.0f}
  1877. };
  1878. static const SFG_StrokeStrip ch110st[] =
  1879. {
  1880.  {2,ch110st0},
  1881.  {7,ch110st1}
  1882. };
  1883. static const SFG_StrokeChar ch110 = {70.881f,2,ch110st};
  1884. /* char: 0x6f */
  1885. static const SFG_StrokeVertex ch111st0[] =
  1886. {
  1887.  {28.7895f,66.6667f},
  1888.  {19.2657f,61.9048f},
  1889.  {9.7419f,52.381f},
  1890.  {4.98f,38.0952f},
  1891.  {4.98f,28.5714f},
  1892.  {9.7419f,14.2857f},
  1893.  {19.2657f,4.7619f},
  1894.  {28.7895f,0.0f},
  1895.  {43.0752f,0.0f},
  1896.  {52.599f,4.7619f},
  1897.  {62.1229f,14.2857f},
  1898.  {66.8848f,28.5714f},
  1899.  {66.8848f,38.0952f},
  1900.  {62.1229f,52.381f},
  1901.  {52.599f,61.9048f},
  1902.  {43.0752f,66.6667f},
  1903.  {28.7895f,66.6667f}
  1904. };
  1905. static const SFG_StrokeStrip ch111st[] =
  1906. {
  1907.  {17,ch111st0}
  1908. };
  1909. static const SFG_StrokeChar ch111 = {71.7448f,1,ch111st};
  1910. /* char: 0x70 */
  1911. static const SFG_StrokeVertex ch112st0[] =
  1912. {
  1913.  {9.46f,66.6667f},
  1914.  {9.46f,-33.3333f}
  1915. };
  1916. static const SFG_StrokeVertex ch112st1[] =
  1917. {
  1918.  {9.46f,52.381f},
  1919.  {18.9838f,61.9048f},
  1920.  {28.5076f,66.6667f},
  1921.  {42.7933f,66.6667f},
  1922.  {52.3171f,61.9048f},
  1923.  {61.841f,52.381f},
  1924.  {66.6029f,38.0952f},
  1925.  {66.6029f,28.5714f},
  1926.  {61.841f,14.2857f},
  1927.  {52.3171f,4.7619f},
  1928.  {42.7933f,0.0f},
  1929.  {28.5076f,0.0f},
  1930.  {18.9838f,4.7619f},
  1931.  {9.46f,14.2857f}
  1932. };
  1933. static const SFG_StrokeStrip ch112st[] =
  1934. {
  1935.  {2,ch112st0},
  1936.  {14,ch112st1}
  1937. };
  1938. static const SFG_StrokeChar ch112 = {70.8029f,2,ch112st};
  1939. /* char: 0x71 */
  1940. static const SFG_StrokeVertex ch113st0[] =
  1941. {
  1942.  {61.9829f,66.6667f},
  1943.  {61.9829f,-33.3333f}
  1944. };
  1945. static const SFG_StrokeVertex ch113st1[] =
  1946. {
  1947.  {61.9829f,52.381f},
  1948.  {52.459f,61.9048f},
  1949.  {42.9352f,66.6667f},
  1950.  {28.6495f,66.6667f},
  1951.  {19.1257f,61.9048f},
  1952.  {9.6019f,52.381f},
  1953.  {4.84f,38.0952f},
  1954.  {4.84f,28.5714f},
  1955.  {9.6019f,14.2857f},
  1956.  {19.1257f,4.7619f},
  1957.  {28.6495f,0.0f},
  1958.  {42.9352f,0.0f},
  1959.  {52.459f,4.7619f},
  1960.  {61.9829f,14.2857f}
  1961. };
  1962. static const SFG_StrokeStrip ch113st[] =
  1963. {
  1964.  {2,ch113st0},
  1965.  {14,ch113st1}
  1966. };
  1967. static const SFG_StrokeChar ch113 = {70.7429f,2,ch113st};
  1968. /* char: 0x72 */
  1969. static const SFG_StrokeVertex ch114st0[] =
  1970. {
  1971.  {9.46f,66.6667f},
  1972.  {9.46f,0.0f}
  1973. };
  1974. static const SFG_StrokeVertex ch114st1[] =
  1975. {
  1976.  {9.46f,38.0952f},
  1977.  {14.2219f,52.381f},
  1978.  {23.7457f,61.9048f},
  1979.  {33.2695f,66.6667f},
  1980.  {47.5552f,66.6667f}
  1981. };
  1982. static const SFG_StrokeStrip ch114st[] =
  1983. {
  1984.  {2,ch114st0},
  1985.  {5,ch114st1}
  1986. };
  1987. static const SFG_StrokeChar ch114 = {49.4952f,2,ch114st};
  1988. /* char: 0x73 */
  1989. static const SFG_StrokeVertex ch115st0[] =
  1990. {
  1991.  {57.081f,52.381f},
  1992.  {52.319f,61.9048f},
  1993.  {38.0333f,66.6667f},
  1994.  {23.7476f,66.6667f},
  1995.  {9.4619f,61.9048f},
  1996.  {4.7f,52.381f},
  1997.  {9.4619f,42.8571f},
  1998.  {18.9857f,38.0952f},
  1999.  {42.7952f,33.3333f},
  2000.  {52.319f,28.5714f},
  2001.  {57.081f,19.0476f},
  2002.  {57.081f,14.2857f},
  2003.  {52.319f,4.7619f},
  2004.  {38.0333f,0.0f},
  2005.  {23.7476f,0.0f},
  2006.  {9.4619f,4.7619f},
  2007.  {4.7f,14.2857f}
  2008. };
  2009. static const SFG_StrokeStrip ch115st[] =
  2010. {
  2011.  {17,ch115st0}
  2012. };
  2013. static const SFG_StrokeChar ch115 = {62.321f,1,ch115st};
  2014. /* char: 0x74 */
  2015. static const SFG_StrokeVertex ch116st0[] =
  2016. {
  2017.  {14.8257f,100.0f},
  2018.  {14.8257f,19.0476f},
  2019.  {19.5876f,4.7619f},
  2020.  {29.1114f,0.0f},
  2021.  {38.6352f,0.0f}
  2022. };
  2023. static const SFG_StrokeVertex ch116st1[] =
  2024. {
  2025.  {0.54f,66.6667f},
  2026.  {33.8733f,66.6667f}
  2027. };
  2028. static const SFG_StrokeStrip ch116st[] =
  2029. {
  2030.  {5,ch116st0},
  2031.  {2,ch116st1}
  2032. };
  2033. static const SFG_StrokeChar ch116 = {39.3152f,2,ch116st};
  2034. /* char: 0x75 */
  2035. static const SFG_StrokeVertex ch117st0[] =
  2036. {
  2037.  {9.46f,66.6667f},
  2038.  {9.46f,19.0476f},
  2039.  {14.2219f,4.7619f},
  2040.  {23.7457f,0.0f},
  2041.  {38.0314f,0.0f},
  2042.  {47.5552f,4.7619f},
  2043.  {61.841f,19.0476f}
  2044. };
  2045. static const SFG_StrokeVertex ch117st1[] =
  2046. {
  2047.  {61.841f,66.6667f},
  2048.  {61.841f,0.0f}
  2049. };
  2050. static const SFG_StrokeStrip ch117st[] =
  2051. {
  2052.  {7,ch117st0},
  2053.  {2,ch117st1}
  2054. };
  2055. static const SFG_StrokeChar ch117 = {71.161f,2,ch117st};
  2056. /* char: 0x76 */
  2057. static const SFG_StrokeVertex ch118st0[] =
  2058. {
  2059.  {1.8f,66.6667f},
  2060.  {30.3714f,0.0f}
  2061. };
  2062. static const SFG_StrokeVertex ch118st1[] =
  2063. {
  2064.  {58.9429f,66.6667f},
  2065.  {30.3714f,0.0f}
  2066. };
  2067. static const SFG_StrokeStrip ch118st[] =
  2068. {
  2069.  {2,ch118st0},
  2070.  {2,ch118st1}
  2071. };
  2072. static const SFG_StrokeChar ch118 = {60.6029f,2,ch118st};
  2073. /* char: 0x77 */
  2074. static const SFG_StrokeVertex ch119st0[] =
  2075. {
  2076.  {2.5f,66.6667f},
  2077.  {21.5476f,0.0f}
  2078. };
  2079. static const SFG_StrokeVertex ch119st1[] =
  2080. {
  2081.  {40.5952f,66.6667f},
  2082.  {21.5476f,0.0f}
  2083. };
  2084. static const SFG_StrokeVertex ch119st2[] =
  2085. {
  2086.  {40.5952f,66.6667f},
  2087.  {59.6429f,0.0f}
  2088. };
  2089. static const SFG_StrokeVertex ch119st3[] =
  2090. {
  2091.  {78.6905f,66.6667f},
  2092.  {59.6429f,0.0f}
  2093. };
  2094. static const SFG_StrokeStrip ch119st[] =
  2095. {
  2096.  {2,ch119st0},
  2097.  {2,ch119st1},
  2098.  {2,ch119st2},
  2099.  {2,ch119st3}
  2100. };
  2101. static const SFG_StrokeChar ch119 = {80.4905f,4,ch119st};
  2102. /* char: 0x78 */
  2103. static const SFG_StrokeVertex ch120st0[] =
  2104. {
  2105.  {1.66f,66.6667f},
  2106.  {54.041f,0.0f}
  2107. };
  2108. static const SFG_StrokeVertex ch120st1[] =
  2109. {
  2110.  {54.041f,66.6667f},
  2111.  {1.66f,0.0f}
  2112. };
  2113. static const SFG_StrokeStrip ch120st[] =
  2114. {
  2115.  {2,ch120st0},
  2116.  {2,ch120st1}
  2117. };
  2118. static const SFG_StrokeChar ch120 = {56.401f,2,ch120st};
  2119. /* char: 0x79 */
  2120. static const SFG_StrokeVertex ch121st0[] =
  2121. {
  2122.  {6.5619f,66.6667f},
  2123.  {35.1333f,0.0f}
  2124. };
  2125. static const SFG_StrokeVertex ch121st1[] =
  2126. {
  2127.  {63.7048f,66.6667f},
  2128.  {35.1333f,0.0f},
  2129.  {25.6095f,-19.0476f},
  2130.  {16.0857f,-28.5714f},
  2131.  {6.5619f,-33.3333f},
  2132.  {1.8f,-33.3333f}
  2133. };
  2134. static const SFG_StrokeStrip ch121st[] =
  2135. {
  2136.  {2,ch121st0},
  2137.  {6,ch121st1}
  2138. };
  2139. static const SFG_StrokeChar ch121 = {66.0648f,2,ch121st};
  2140. /* char: 0x7a */
  2141. static const SFG_StrokeVertex ch122st0[] =
  2142. {
  2143.  {56.821f,66.6667f},
  2144.  {4.44f,0.0f}
  2145. };
  2146. static const SFG_StrokeVertex ch122st1[] =
  2147. {
  2148.  {4.44f,66.6667f},
  2149.  {56.821f,66.6667f}
  2150. };
  2151. static const SFG_StrokeVertex ch122st2[] =
  2152. {
  2153.  {4.44f,0.0f},
  2154.  {56.821f,0.0f}
  2155. };
  2156. static const SFG_StrokeStrip ch122st[] =
  2157. {
  2158.  {2,ch122st0},
  2159.  {2,ch122st1},
  2160.  {2,ch122st2}
  2161. };
  2162. static const SFG_StrokeChar ch122 = {61.821f,3,ch122st};
  2163. /* char: 0x7b */
  2164. static const SFG_StrokeVertex ch123st0[] =
  2165. {
  2166.  {31.1895f,119.048f},
  2167.  {21.6657f,114.286f},
  2168.  {16.9038f,109.524f},
  2169.  {12.1419f,100.0f},
  2170.  {12.1419f,90.4762f},
  2171.  {16.9038f,80.9524f},
  2172.  {21.6657f,76.1905f},
  2173.  {26.4276f,66.6667f},
  2174.  {26.4276f,57.1429f},
  2175.  {16.9038f,47.619f}
  2176. };
  2177. static const SFG_StrokeVertex ch123st1[] =
  2178. {
  2179.  {21.6657f,114.286f},
  2180.  {16.9038f,104.762f},
  2181.  {16.9038f,95.2381f},
  2182.  {21.6657f,85.7143f},
  2183.  {26.4276f,80.9524f},
  2184.  {31.1895f,71.4286f},
  2185.  {31.1895f,61.9048f},
  2186.  {26.4276f,52.381f},
  2187.  {7.38f,42.8571f},
  2188.  {26.4276f,33.3333f},
  2189.  {31.1895f,23.8095f},
  2190.  {31.1895f,14.2857f},
  2191.  {26.4276f,4.7619f},
  2192.  {21.6657f,0.0f},
  2193.  {16.9038f,-9.5238f},
  2194.  {16.9038f,-19.0476f},
  2195.  {21.6657f,-28.5714f}
  2196. };
  2197. static const SFG_StrokeVertex ch123st2[] =
  2198. {
  2199.  {16.9038f,38.0952f},
  2200.  {26.4276f,28.5714f},
  2201.  {26.4276f,19.0476f},
  2202.  {21.6657f,9.5238f},
  2203.  {16.9038f,4.7619f},
  2204.  {12.1419f,-4.7619f},
  2205.  {12.1419f,-14.2857f},
  2206.  {16.9038f,-23.8095f},
  2207.  {21.6657f,-28.5714f},
  2208.  {31.1895f,-33.3333f}
  2209. };
  2210. static const SFG_StrokeStrip ch123st[] =
  2211. {
  2212.  {10,ch123st0},
  2213.  {17,ch123st1},
  2214.  {10,ch123st2}
  2215. };
  2216. static const SFG_StrokeChar ch123 = {41.6295f,3,ch123st};
  2217. /* char: 0x7c */
  2218. static const SFG_StrokeVertex ch124st0[] =
  2219. {
  2220.  {11.54f,119.048f},
  2221.  {11.54f,-33.3333f}
  2222. };
  2223. static const SFG_StrokeStrip ch124st[] =
  2224. {
  2225.  {2,ch124st0}
  2226. };
  2227. static const SFG_StrokeChar ch124 = {23.78f,1,ch124st};
  2228. /* char: 0x7d */
  2229. static const SFG_StrokeVertex ch125st0[] =
  2230. {
  2231.  {9.18f,119.048f},
  2232.  {18.7038f,114.286f},
  2233.  {23.4657f,109.524f},
  2234.  {28.2276f,100.0f},
  2235.  {28.2276f,90.4762f},
  2236.  {23.4657f,80.9524f},
  2237.  {18.7038f,76.1905f},
  2238.  {13.9419f,66.6667f},
  2239.  {13.9419f,57.1429f},
  2240.  {23.4657f,47.619f}
  2241. };
  2242. static const SFG_StrokeVertex ch125st1[] =
  2243. {
  2244.  {18.7038f,114.286f},
  2245.  {23.4657f,104.762f},
  2246.  {23.4657f,95.2381f},
  2247.  {18.7038f,85.7143f},
  2248.  {13.9419f,80.9524f},
  2249.  {9.18f,71.4286f},
  2250.  {9.18f,61.9048f},
  2251.  {13.9419f,52.381f},
  2252.  {32.9895f,42.8571f},
  2253.  {13.9419f,33.3333f},
  2254.  {9.18f,23.8095f},
  2255.  {9.18f,14.2857f},
  2256.  {13.9419f,4.7619f},
  2257.  {18.7038f,0.0f},
  2258.  {23.4657f,-9.5238f},
  2259.  {23.4657f,-19.0476f},
  2260.  {18.7038f,-28.5714f}
  2261. };
  2262. static const SFG_StrokeVertex ch125st2[] =
  2263. {
  2264.  {23.4657f,38.0952f},
  2265.  {13.9419f,28.5714f},
  2266.  {13.9419f,19.0476f},
  2267.  {18.7038f,9.5238f},
  2268.  {23.4657f,4.7619f},
  2269.  {28.2276f,-4.7619f},
  2270.  {28.2276f,-14.2857f},
  2271.  {23.4657f,-23.8095f},
  2272.  {18.7038f,-28.5714f},
  2273.  {9.18f,-33.3333f}
  2274. };
  2275. static const SFG_StrokeStrip ch125st[] =
  2276. {
  2277.  {10,ch125st0},
  2278.  {17,ch125st1},
  2279.  {10,ch125st2}
  2280. };
  2281. static const SFG_StrokeChar ch125 = {41.4695f,3,ch125st};
  2282. /* char: 0x7e */
  2283. static const SFG_StrokeVertex ch126st0[] =
  2284. {
  2285.  {2.92f,28.5714f},
  2286.  {2.92f,38.0952f},
  2287.  {7.6819f,52.381f},
  2288.  {17.2057f,57.1429f},
  2289.  {26.7295f,57.1429f},
  2290.  {36.2533f,52.381f},
  2291.  {55.301f,38.0952f},
  2292.  {64.8248f,33.3333f},
  2293.  {74.3486f,33.3333f},
  2294.  {83.8724f,38.0952f},
  2295.  {88.6343f,47.619f}
  2296. };
  2297. static const SFG_StrokeVertex ch126st1[] =
  2298. {
  2299.  {2.92f,38.0952f},
  2300.  {7.6819f,47.619f},
  2301.  {17.2057f,52.381f},
  2302.  {26.7295f,52.381f},
  2303.  {36.2533f,47.619f},
  2304.  {55.301f,33.3333f},
  2305.  {64.8248f,28.5714f},
  2306.  {74.3486f,28.5714f},
  2307.  {83.8724f,33.3333f},
  2308.  {88.6343f,47.619f},
  2309.  {88.6343f,57.1429f}
  2310. };
  2311. static const SFG_StrokeStrip ch126st[] =
  2312. {
  2313.  {11,ch126st0},
  2314.  {11,ch126st1}
  2315. };
  2316. static const SFG_StrokeChar ch126 = {91.2743f,2,ch126st};
  2317. /* char: 0x7f */
  2318. static const SFG_StrokeVertex ch127st0[] =
  2319. {
  2320.  {52.381f,100.0f},
  2321.  {14.2857f,-33.3333f}
  2322. };
  2323. static const SFG_StrokeVertex ch127st1[] =
  2324. {
  2325.  {28.5714f,66.6667f},
  2326.  {14.2857f,61.9048f},
  2327.  {4.7619f,52.381f},
  2328.  {0.0f,38.0952f},
  2329.  {0.0f,23.8095f},
  2330.  {4.7619f,14.2857f},
  2331.  {14.2857f,4.7619f},
  2332.  {28.5714f,0.0f},
  2333.  {38.0952f,0.0f},
  2334.  {52.381f,4.7619f},
  2335.  {61.9048f,14.2857f},
  2336.  {66.6667f,28.5714f},
  2337.  {66.6667f,42.8571f},
  2338.  {61.9048f,52.381f},
  2339.  {52.381f,61.9048f},
  2340.  {38.0952f,66.6667f},
  2341.  {28.5714f,66.6667f}
  2342. };
  2343. static const SFG_StrokeStrip ch127st[] =
  2344. {
  2345.  {2,ch127st0},
  2346.  {17,ch127st1}
  2347. };
  2348. static const SFG_StrokeChar ch127 = {66.6667f,2,ch127st};
  2349. static const SFG_StrokeChar *chars[] =
  2350. {
  2351.  0, 0, 0, 0, 0, 0, 0, 0,
  2352.  0, 0, 0, 0, 0, 0, 0, 0,
  2353.  0, 0, 0, 0, 0, 0, 0, 0,
  2354.  0, 0, 0, 0, 0, 0, 0, 0,
  2355.  &ch32, &ch33, &ch34, &ch35, &ch36, &ch37, &ch38, &ch39,
  2356.  &ch40, &ch41, &ch42, &ch43, &ch44, &ch45, &ch46, &ch47,
  2357.  &ch48, &ch49, &ch50, &ch51, &ch52, &ch53, &ch54, &ch55,
  2358.  &ch56, &ch57, &ch58, &ch59, &ch60, &ch61, &ch62, &ch63,
  2359.  &ch64, &ch65, &ch66, &ch67, &ch68, &ch69, &ch70, &ch71,
  2360.  &ch72, &ch73, &ch74, &ch75, &ch76, &ch77, &ch78, &ch79,
  2361.  &ch80, &ch81, &ch82, &ch83, &ch84, &ch85, &ch86, &ch87,
  2362.  &ch88, &ch89, &ch90, &ch91, &ch92, &ch93, &ch94, &ch95,
  2363.  &ch96, &ch97, &ch98, &ch99, &ch100, &ch101, &ch102, &ch103,
  2364.  &ch104, &ch105, &ch106, &ch107, &ch108, &ch109, &ch110, &ch111,
  2365.  &ch112, &ch113, &ch114, &ch115, &ch116, &ch117, &ch118, &ch119,
  2366.  &ch120, &ch121, &ch122, &ch123, &ch124, &ch125, &ch126, &ch127
  2367. };
  2368. const SFG_StrokeFont fgStrokeRoman = {"Roman",128,152.381f,chars};