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

游戏引擎

开发平台:

Visual C++

  1. /*
  2.  * freeglut_stroke_mono_roman.c
  3.  *
  4.  * freeglut Monospace 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.  {52.381f,100.0f},
  40.  {52.381f,33.3333f}
  41. };
  42. static const SFG_StrokeVertex ch33st1[] =
  43. {
  44.  {52.381f,9.5238f},
  45.  {47.6191f,4.7619f},
  46.  {52.381f,0.0f},
  47.  {57.1429f,4.7619f},
  48.  {52.381f,9.5238f}
  49. };
  50. static const SFG_StrokeStrip ch33st[] =
  51. {
  52.  {2,ch33st0},
  53.  {5,ch33st1}
  54. };
  55. static const SFG_StrokeChar ch33 = {104.762f,2,ch33st};
  56. /* char: 0x22 */
  57. static const SFG_StrokeVertex ch34st0[] =
  58. {
  59.  {33.3334f,100.0f},
  60.  {33.3334f,66.6667f}
  61. };
  62. static const SFG_StrokeVertex ch34st1[] =
  63. {
  64.  {71.4286f,100.0f},
  65.  {71.4286f,66.6667f}
  66. };
  67. static const SFG_StrokeStrip ch34st[] =
  68. {
  69.  {2,ch34st0},
  70.  {2,ch34st1}
  71. };
  72. static const SFG_StrokeChar ch34 = {104.762f,2,ch34st};
  73. /* char: 0x23 */
  74. static const SFG_StrokeVertex ch35st0[] =
  75. {
  76.  {54.7619f,119.048f},
  77.  {21.4286f,-33.3333f}
  78. };
  79. static const SFG_StrokeVertex ch35st1[] =
  80. {
  81.  {83.3334f,119.048f},
  82.  {50.0f,-33.3333f}
  83. };
  84. static const SFG_StrokeVertex ch35st2[] =
  85. {
  86.  {21.4286f,57.1429f},
  87.  {88.0952f,57.1429f}
  88. };
  89. static const SFG_StrokeVertex ch35st3[] =
  90. {
  91.  {16.6667f,28.5714f},
  92.  {83.3334f,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 = {104.762f,4,ch35st};
  102. /* char: 0x24 */
  103. static const SFG_StrokeVertex ch36st0[] =
  104. {
  105.  {42.8571f,119.048f},
  106.  {42.8571f,-19.0476f}
  107. };
  108. static const SFG_StrokeVertex ch36st1[] =
  109. {
  110.  {61.9047f,119.048f},
  111.  {61.9047f,-19.0476f}
  112. };
  113. static const SFG_StrokeVertex ch36st2[] =
  114. {
  115.  {85.7143f,85.7143f},
  116.  {76.1905f,95.2381f},
  117.  {61.9047f,100.0f},
  118.  {42.8571f,100.0f},
  119.  {28.5714f,95.2381f},
  120.  {19.0476f,85.7143f},
  121.  {19.0476f,76.1905f},
  122.  {23.8095f,66.6667f},
  123.  {28.5714f,61.9048f},
  124.  {38.0952f,57.1429f},
  125.  {66.6666f,47.619f},
  126.  {76.1905f,42.8571f},
  127.  {80.9524f,38.0952f},
  128.  {85.7143f,28.5714f},
  129.  {85.7143f,14.2857f},
  130.  {76.1905f,4.7619f},
  131.  {61.9047f,0.0f},
  132.  {42.8571f,0.0f},
  133.  {28.5714f,4.7619f},
  134.  {19.0476f,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 = {104.762f,3,ch36st};
  143. /* char: 0x25 */
  144. static const SFG_StrokeVertex ch37st0[] =
  145. {
  146.  {95.2381f,100.0f},
  147.  {9.5238f,0.0f}
  148. };
  149. static const SFG_StrokeVertex ch37st1[] =
  150. {
  151.  {33.3333f,100.0f},
  152.  {42.8571f,90.4762f},
  153.  {42.8571f,80.9524f},
  154.  {38.0952f,71.4286f},
  155.  {28.5714f,66.6667f},
  156.  {19.0476f,66.6667f},
  157.  {9.5238f,76.1905f},
  158.  {9.5238f,85.7143f},
  159.  {14.2857f,95.2381f},
  160.  {23.8095f,100.0f},
  161.  {33.3333f,100.0f},
  162.  {42.8571f,95.2381f},
  163.  {57.1428f,90.4762f},
  164.  {71.4286f,90.4762f},
  165.  {85.7143f,95.2381f},
  166.  {95.2381f,100.0f}
  167. };
  168. static const SFG_StrokeVertex ch37st2[] =
  169. {
  170.  {76.1905f,33.3333f},
  171.  {66.6667f,28.5714f},
  172.  {61.9048f,19.0476f},
  173.  {61.9048f,9.5238f},
  174.  {71.4286f,0.0f},
  175.  {80.9524f,0.0f},
  176.  {90.4762f,4.7619f},
  177.  {95.2381f,14.2857f},
  178.  {95.2381f,23.8095f},
  179.  {85.7143f,33.3333f},
  180.  {76.1905f,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 = {104.762f,3,ch37st};
  189. /* char: 0x26 */
  190. static const SFG_StrokeVertex ch38st0[] =
  191. {
  192.  {100.0f,57.1429f},
  193.  {100.0f,61.9048f},
  194.  {95.2381f,66.6667f},
  195.  {90.4762f,66.6667f},
  196.  {85.7143f,61.9048f},
  197.  {80.9524f,52.381f},
  198.  {71.4286f,28.5714f},
  199.  {61.9048f,14.2857f},
  200.  {52.3809f,4.7619f},
  201.  {42.8571f,0.0f},
  202.  {23.8095f,0.0f},
  203.  {14.2857f,4.7619f},
  204.  {9.5238f,9.5238f},
  205.  {4.7619f,19.0476f},
  206.  {4.7619f,28.5714f},
  207.  {9.5238f,38.0952f},
  208.  {14.2857f,42.8571f},
  209.  {47.619f,61.9048f},
  210.  {52.3809f,66.6667f},
  211.  {57.1429f,76.1905f},
  212.  {57.1429f,85.7143f},
  213.  {52.3809f,95.2381f},
  214.  {42.8571f,100.0f},
  215.  {33.3333f,95.2381f},
  216.  {28.5714f,85.7143f},
  217.  {28.5714f,76.1905f},
  218.  {33.3333f,61.9048f},
  219.  {42.8571f,47.619f},
  220.  {66.6667f,14.2857f},
  221.  {76.1905f,4.7619f},
  222.  {85.7143f,0.0f},
  223.  {95.2381f,0.0f},
  224.  {100.0f,4.7619f},
  225.  {100.0f,9.5238f}
  226. };
  227. static const SFG_StrokeStrip ch38st[] =
  228. {
  229.  {34,ch38st0}
  230. };
  231. static const SFG_StrokeChar ch38 = {104.762f,1,ch38st};
  232. /* char: 0x27 */
  233. static const SFG_StrokeVertex ch39st0[] =
  234. {
  235.  {52.381f,100.0f},
  236.  {52.381f,66.6667f}
  237. };
  238. static const SFG_StrokeStrip ch39st[] =
  239. {
  240.  {2,ch39st0}
  241. };
  242. static const SFG_StrokeChar ch39 = {104.762f,1,ch39st};
  243. /* char: 0x28 */
  244. static const SFG_StrokeVertex ch40st0[] =
  245. {
  246.  {69.0476f,119.048f},
  247.  {59.5238f,109.524f},
  248.  {50.0f,95.2381f},
  249.  {40.4762f,76.1905f},
  250.  {35.7143f,52.381f},
  251.  {35.7143f,33.3333f},
  252.  {40.4762f,9.5238f},
  253.  {50.0f,-9.5238f},
  254.  {59.5238f,-23.8095f},
  255.  {69.0476f,-33.3333f}
  256. };
  257. static const SFG_StrokeStrip ch40st[] =
  258. {
  259.  {10,ch40st0}
  260. };
  261. static const SFG_StrokeChar ch40 = {104.762f,1,ch40st};
  262. /* char: 0x29 */
  263. static const SFG_StrokeVertex ch41st0[] =
  264. {
  265.  {35.7143f,119.048f},
  266.  {45.2381f,109.524f},
  267.  {54.7619f,95.2381f},
  268.  {64.2857f,76.1905f},
  269.  {69.0476f,52.381f},
  270.  {69.0476f,33.3333f},
  271.  {64.2857f,9.5238f},
  272.  {54.7619f,-9.5238f},
  273.  {45.2381f,-23.8095f},
  274.  {35.7143f,-33.3333f}
  275. };
  276. static const SFG_StrokeStrip ch41st[] =
  277. {
  278.  {10,ch41st0}
  279. };
  280. static const SFG_StrokeChar ch41 = {104.762f,1,ch41st};
  281. /* char: 0x2a */
  282. static const SFG_StrokeVertex ch42st0[] =
  283. {
  284.  {52.381f,71.4286f},
  285.  {52.381f,14.2857f}
  286. };
  287. static const SFG_StrokeVertex ch42st1[] =
  288. {
  289.  {28.5715f,57.1429f},
  290.  {76.1905f,28.5714f}
  291. };
  292. static const SFG_StrokeVertex ch42st2[] =
  293. {
  294.  {76.1905f,57.1429f},
  295.  {28.5715f,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 = {104.762f,3,ch42st};
  304. /* char: 0x2b */
  305. static const SFG_StrokeVertex ch43st0[] =
  306. {
  307.  {52.3809f,85.7143f},
  308.  {52.3809f,0.0f}
  309. };
  310. static const SFG_StrokeVertex ch43st1[] =
  311. {
  312.  {9.5238f,42.8571f},
  313.  {95.2381f,42.8571f}
  314. };
  315. static const SFG_StrokeStrip ch43st[] =
  316. {
  317.  {2,ch43st0},
  318.  {2,ch43st1}
  319. };
  320. static const SFG_StrokeChar ch43 = {104.762f,2,ch43st};
  321. /* char: 0x2c */
  322. static const SFG_StrokeVertex ch44st0[] =
  323. {
  324.  {57.1429f,4.7619f},
  325.  {52.381f,0.0f},
  326.  {47.6191f,4.7619f},
  327.  {52.381f,9.5238f},
  328.  {57.1429f,4.7619f},
  329.  {57.1429f,-4.7619f},
  330.  {52.381f,-14.2857f},
  331.  {47.6191f,-19.0476f}
  332. };
  333. static const SFG_StrokeStrip ch44st[] =
  334. {
  335.  {8,ch44st0}
  336. };
  337. static const SFG_StrokeChar ch44 = {104.762f,1,ch44st};
  338. /* char: 0x2d */
  339. static const SFG_StrokeVertex ch45st0[] =
  340. {
  341.  {9.5238f,42.8571f},
  342.  {95.2381f,42.8571f}
  343. };
  344. static const SFG_StrokeStrip ch45st[] =
  345. {
  346.  {2,ch45st0}
  347. };
  348. static const SFG_StrokeChar ch45 = {104.762f,1,ch45st};
  349. /* char: 0x2e */
  350. static const SFG_StrokeVertex ch46st0[] =
  351. {
  352.  {52.381f,9.5238f},
  353.  {47.6191f,4.7619f},
  354.  {52.381f,0.0f},
  355.  {57.1429f,4.7619f},
  356.  {52.381f,9.5238f}
  357. };
  358. static const SFG_StrokeStrip ch46st[] =
  359. {
  360.  {5,ch46st0}
  361. };
  362. static const SFG_StrokeChar ch46 = {104.762f,1,ch46st};
  363. /* char: 0x2f */
  364. static const SFG_StrokeVertex ch47st0[] =
  365. {
  366.  {19.0476f,-14.2857f},
  367.  {85.7143f,100.0f}
  368. };
  369. static const SFG_StrokeStrip ch47st[] =
  370. {
  371.  {2,ch47st0}
  372. };
  373. static const SFG_StrokeChar ch47 = {104.762f,1,ch47st};
  374. /* char: 0x30 */
  375. static const SFG_StrokeVertex ch48st0[] =
  376. {
  377.  {47.619f,100.0f},
  378.  {33.3333f,95.2381f},
  379.  {23.8095f,80.9524f},
  380.  {19.0476f,57.1429f},
  381.  {19.0476f,42.8571f},
  382.  {23.8095f,19.0476f},
  383.  {33.3333f,4.7619f},
  384.  {47.619f,0.0f},
  385.  {57.1428f,0.0f},
  386.  {71.4286f,4.7619f},
  387.  {80.9524f,19.0476f},
  388.  {85.7143f,42.8571f},
  389.  {85.7143f,57.1429f},
  390.  {80.9524f,80.9524f},
  391.  {71.4286f,95.2381f},
  392.  {57.1428f,100.0f},
  393.  {47.619f,100.0f}
  394. };
  395. static const SFG_StrokeStrip ch48st[] =
  396. {
  397.  {17,ch48st0}
  398. };
  399. static const SFG_StrokeChar ch48 = {104.762f,1,ch48st};
  400. /* char: 0x31 */
  401. static const SFG_StrokeVertex ch49st0[] =
  402. {
  403.  {40.4762f,80.9524f},
  404.  {50.0f,85.7143f},
  405.  {64.2857f,100.0f},
  406.  {64.2857f,0.0f}
  407. };
  408. static const SFG_StrokeStrip ch49st[] =
  409. {
  410.  {4,ch49st0}
  411. };
  412. static const SFG_StrokeChar ch49 = {104.762f,1,ch49st};
  413. /* char: 0x32 */
  414. static const SFG_StrokeVertex ch50st0[] =
  415. {
  416.  {23.8095f,76.1905f},
  417.  {23.8095f,80.9524f},
  418.  {28.5714f,90.4762f},
  419.  {33.3333f,95.2381f},
  420.  {42.8571f,100.0f},
  421.  {61.9047f,100.0f},
  422.  {71.4286f,95.2381f},
  423.  {76.1905f,90.4762f},
  424.  {80.9524f,80.9524f},
  425.  {80.9524f,71.4286f},
  426.  {76.1905f,61.9048f},
  427.  {66.6666f,47.619f},
  428.  {19.0476f,0.0f},
  429.  {85.7143f,0.0f}
  430. };
  431. static const SFG_StrokeStrip ch50st[] =
  432. {
  433.  {14,ch50st0}
  434. };
  435. static const SFG_StrokeChar ch50 = {104.762f,1,ch50st};
  436. /* char: 0x33 */
  437. static const SFG_StrokeVertex ch51st0[] =
  438. {
  439.  {28.5714f,100.0f},
  440.  {80.9524f,100.0f},
  441.  {52.3809f,61.9048f},
  442.  {66.6666f,61.9048f},
  443.  {76.1905f,57.1429f},
  444.  {80.9524f,52.381f},
  445.  {85.7143f,38.0952f},
  446.  {85.7143f,28.5714f},
  447.  {80.9524f,14.2857f},
  448.  {71.4286f,4.7619f},
  449.  {57.1428f,0.0f},
  450.  {42.8571f,0.0f},
  451.  {28.5714f,4.7619f},
  452.  {23.8095f,9.5238f},
  453.  {19.0476f,19.0476f}
  454. };
  455. static const SFG_StrokeStrip ch51st[] =
  456. {
  457.  {15,ch51st0}
  458. };
  459. static const SFG_StrokeChar ch51 = {104.762f,1,ch51st};
  460. /* char: 0x34 */
  461. static const SFG_StrokeVertex ch52st0[] =
  462. {
  463.  {64.2857f,100.0f},
  464.  {16.6667f,33.3333f},
  465.  {88.0952f,33.3333f}
  466. };
  467. static const SFG_StrokeVertex ch52st1[] =
  468. {
  469.  {64.2857f,100.0f},
  470.  {64.2857f,0.0f}
  471. };
  472. static const SFG_StrokeStrip ch52st[] =
  473. {
  474.  {3,ch52st0},
  475.  {2,ch52st1}
  476. };
  477. static const SFG_StrokeChar ch52 = {104.762f,2,ch52st};
  478. /* char: 0x35 */
  479. static const SFG_StrokeVertex ch53st0[] =
  480. {
  481.  {76.1905f,100.0f},
  482.  {28.5714f,100.0f},
  483.  {23.8095f,57.1429f},
  484.  {28.5714f,61.9048f},
  485.  {42.8571f,66.6667f},
  486.  {57.1428f,66.6667f},
  487.  {71.4286f,61.9048f},
  488.  {80.9524f,52.381f},
  489.  {85.7143f,38.0952f},
  490.  {85.7143f,28.5714f},
  491.  {80.9524f,14.2857f},
  492.  {71.4286f,4.7619f},
  493.  {57.1428f,0.0f},
  494.  {42.8571f,0.0f},
  495.  {28.5714f,4.7619f},
  496.  {23.8095f,9.5238f},
  497.  {19.0476f,19.0476f}
  498. };
  499. static const SFG_StrokeStrip ch53st[] =
  500. {
  501.  {17,ch53st0}
  502. };
  503. static const SFG_StrokeChar ch53 = {104.762f,1,ch53st};
  504. /* char: 0x36 */
  505. static const SFG_StrokeVertex ch54st0[] =
  506. {
  507.  {78.5714f,85.7143f},
  508.  {73.8096f,95.2381f},
  509.  {59.5238f,100.0f},
  510.  {50.0f,100.0f},
  511.  {35.7143f,95.2381f},
  512.  {26.1905f,80.9524f},
  513.  {21.4286f,57.1429f},
  514.  {21.4286f,33.3333f},
  515.  {26.1905f,14.2857f},
  516.  {35.7143f,4.7619f},
  517.  {50.0f,0.0f},
  518.  {54.7619f,0.0f},
  519.  {69.0476f,4.7619f},
  520.  {78.5714f,14.2857f},
  521.  {83.3334f,28.5714f},
  522.  {83.3334f,33.3333f},
  523.  {78.5714f,47.619f},
  524.  {69.0476f,57.1429f},
  525.  {54.7619f,61.9048f},
  526.  {50.0f,61.9048f},
  527.  {35.7143f,57.1429f},
  528.  {26.1905f,47.619f},
  529.  {21.4286f,33.3333f}
  530. };
  531. static const SFG_StrokeStrip ch54st[] =
  532. {
  533.  {23,ch54st0}
  534. };
  535. static const SFG_StrokeChar ch54 = {104.762f,1,ch54st};
  536. /* char: 0x37 */
  537. static const SFG_StrokeVertex ch55st0[] =
  538. {
  539.  {85.7143f,100.0f},
  540.  {38.0952f,0.0f}
  541. };
  542. static const SFG_StrokeVertex ch55st1[] =
  543. {
  544.  {19.0476f,100.0f},
  545.  {85.7143f,100.0f}
  546. };
  547. static const SFG_StrokeStrip ch55st[] =
  548. {
  549.  {2,ch55st0},
  550.  {2,ch55st1}
  551. };
  552. static const SFG_StrokeChar ch55 = {104.762f,2,ch55st};
  553. /* char: 0x38 */
  554. static const SFG_StrokeVertex ch56st0[] =
  555. {
  556.  {42.8571f,100.0f},
  557.  {28.5714f,95.2381f},
  558.  {23.8095f,85.7143f},
  559.  {23.8095f,76.1905f},
  560.  {28.5714f,66.6667f},
  561.  {38.0952f,61.9048f},
  562.  {57.1428f,57.1429f},
  563.  {71.4286f,52.381f},
  564.  {80.9524f,42.8571f},
  565.  {85.7143f,33.3333f},
  566.  {85.7143f,19.0476f},
  567.  {80.9524f,9.5238f},
  568.  {76.1905f,4.7619f},
  569.  {61.9047f,0.0f},
  570.  {42.8571f,0.0f},
  571.  {28.5714f,4.7619f},
  572.  {23.8095f,9.5238f},
  573.  {19.0476f,19.0476f},
  574.  {19.0476f,33.3333f},
  575.  {23.8095f,42.8571f},
  576.  {33.3333f,52.381f},
  577.  {47.619f,57.1429f},
  578.  {66.6666f,61.9048f},
  579.  {76.1905f,66.6667f},
  580.  {80.9524f,76.1905f},
  581.  {80.9524f,85.7143f},
  582.  {76.1905f,95.2381f},
  583.  {61.9047f,100.0f},
  584.  {42.8571f,100.0f}
  585. };
  586. static const SFG_StrokeStrip ch56st[] =
  587. {
  588.  {29,ch56st0}
  589. };
  590. static const SFG_StrokeChar ch56 = {104.762f,1,ch56st};
  591. /* char: 0x39 */
  592. static const SFG_StrokeVertex ch57st0[] =
  593. {
  594.  {83.3334f,66.6667f},
  595.  {78.5714f,52.381f},
  596.  {69.0476f,42.8571f},
  597.  {54.7619f,38.0952f},
  598.  {50.0f,38.0952f},
  599.  {35.7143f,42.8571f},
  600.  {26.1905f,52.381f},
  601.  {21.4286f,66.6667f},
  602.  {21.4286f,71.4286f},
  603.  {26.1905f,85.7143f},
  604.  {35.7143f,95.2381f},
  605.  {50.0f,100.0f},
  606.  {54.7619f,100.0f},
  607.  {69.0476f,95.2381f},
  608.  {78.5714f,85.7143f},
  609.  {83.3334f,66.6667f},
  610.  {83.3334f,42.8571f},
  611.  {78.5714f,19.0476f},
  612.  {69.0476f,4.7619f},
  613.  {54.7619f,0.0f},
  614.  {45.2381f,0.0f},
  615.  {30.9524f,4.7619f},
  616.  {26.1905f,14.2857f}
  617. };
  618. static const SFG_StrokeStrip ch57st[] =
  619. {
  620.  {23,ch57st0}
  621. };
  622. static const SFG_StrokeChar ch57 = {104.762f,1,ch57st};
  623. /* char: 0x3a */
  624. static const SFG_StrokeVertex ch58st0[] =
  625. {
  626.  {52.381f,66.6667f},
  627.  {47.6191f,61.9048f},
  628.  {52.381f,57.1429f},
  629.  {57.1429f,61.9048f},
  630.  {52.381f,66.6667f}
  631. };
  632. static const SFG_StrokeVertex ch58st1[] =
  633. {
  634.  {52.381f,9.5238f},
  635.  {47.6191f,4.7619f},
  636.  {52.381f,0.0f},
  637.  {57.1429f,4.7619f},
  638.  {52.381f,9.5238f}
  639. };
  640. static const SFG_StrokeStrip ch58st[] =
  641. {
  642.  {5,ch58st0},
  643.  {5,ch58st1}
  644. };
  645. static const SFG_StrokeChar ch58 = {104.762f,2,ch58st};
  646. /* char: 0x3b */
  647. static const SFG_StrokeVertex ch59st0[] =
  648. {
  649.  {52.381f,66.6667f},
  650.  {47.6191f,61.9048f},
  651.  {52.381f,57.1429f},
  652.  {57.1429f,61.9048f},
  653.  {52.381f,66.6667f}
  654. };
  655. static const SFG_StrokeVertex ch59st1[] =
  656. {
  657.  {57.1429f,4.7619f},
  658.  {52.381f,0.0f},
  659.  {47.6191f,4.7619f},
  660.  {52.381f,9.5238f},
  661.  {57.1429f,4.7619f},
  662.  {57.1429f,-4.7619f},
  663.  {52.381f,-14.2857f},
  664.  {47.6191f,-19.0476f}
  665. };
  666. static const SFG_StrokeStrip ch59st[] =
  667. {
  668.  {5,ch59st0},
  669.  {8,ch59st1}
  670. };
  671. static const SFG_StrokeChar ch59 = {104.762f,2,ch59st};
  672. /* char: 0x3c */
  673. static const SFG_StrokeVertex ch60st0[] =
  674. {
  675.  {90.4762f,85.7143f},
  676.  {14.2857f,42.8571f},
  677.  {90.4762f,0.0f}
  678. };
  679. static const SFG_StrokeStrip ch60st[] =
  680. {
  681.  {3,ch60st0}
  682. };
  683. static const SFG_StrokeChar ch60 = {104.762f,1,ch60st};
  684. /* char: 0x3d */
  685. static const SFG_StrokeVertex ch61st0[] =
  686. {
  687.  {9.5238f,57.1429f},
  688.  {95.2381f,57.1429f}
  689. };
  690. static const SFG_StrokeVertex ch61st1[] =
  691. {
  692.  {9.5238f,28.5714f},
  693.  {95.2381f,28.5714f}
  694. };
  695. static const SFG_StrokeStrip ch61st[] =
  696. {
  697.  {2,ch61st0},
  698.  {2,ch61st1}
  699. };
  700. static const SFG_StrokeChar ch61 = {104.762f,2,ch61st};
  701. /* char: 0x3e */
  702. static const SFG_StrokeVertex ch62st0[] =
  703. {
  704.  {14.2857f,85.7143f},
  705.  {90.4762f,42.8571f},
  706.  {14.2857f,0.0f}
  707. };
  708. static const SFG_StrokeStrip ch62st[] =
  709. {
  710.  {3,ch62st0}
  711. };
  712. static const SFG_StrokeChar ch62 = {104.762f,1,ch62st};
  713. /* char: 0x3f */
  714. static const SFG_StrokeVertex ch63st0[] =
  715. {
  716.  {23.8095f,76.1905f},
  717.  {23.8095f,80.9524f},
  718.  {28.5714f,90.4762f},
  719.  {33.3333f,95.2381f},
  720.  {42.8571f,100.0f},
  721.  {61.9047f,100.0f},
  722.  {71.4285f,95.2381f},
  723.  {76.1905f,90.4762f},
  724.  {80.9524f,80.9524f},
  725.  {80.9524f,71.4286f},
  726.  {76.1905f,61.9048f},
  727.  {71.4285f,57.1429f},
  728.  {52.3809f,47.619f},
  729.  {52.3809f,33.3333f}
  730. };
  731. static const SFG_StrokeVertex ch63st1[] =
  732. {
  733.  {52.3809f,9.5238f},
  734.  {47.619f,4.7619f},
  735.  {52.3809f,0.0f},
  736.  {57.1428f,4.7619f},
  737.  {52.3809f,9.5238f}
  738. };
  739. static const SFG_StrokeStrip ch63st[] =
  740. {
  741.  {14,ch63st0},
  742.  {5,ch63st1}
  743. };
  744. static const SFG_StrokeChar ch63 = {104.762f,2,ch63st};
  745. /* char: 0x40 */
  746. static const SFG_StrokeVertex ch64st0[] =
  747. {
  748.  {64.2857f,52.381f},
  749.  {54.7619f,57.1429f},
  750.  {45.2381f,57.1429f},
  751.  {40.4762f,47.619f},
  752.  {40.4762f,42.8571f},
  753.  {45.2381f,33.3333f},
  754.  {54.7619f,33.3333f},
  755.  {64.2857f,38.0952f}
  756. };
  757. static const SFG_StrokeVertex ch64st1[] =
  758. {
  759.  {64.2857f,57.1429f},
  760.  {64.2857f,38.0952f},
  761.  {69.0476f,33.3333f},
  762.  {78.5714f,33.3333f},
  763.  {83.3334f,42.8571f},
  764.  {83.3334f,47.619f},
  765.  {78.5714f,61.9048f},
  766.  {69.0476f,71.4286f},
  767.  {54.7619f,76.1905f},
  768.  {50.0f,76.1905f},
  769.  {35.7143f,71.4286f},
  770.  {26.1905f,61.9048f},
  771.  {21.4286f,47.619f},
  772.  {21.4286f,42.8571f},
  773.  {26.1905f,28.5714f},
  774.  {35.7143f,19.0476f},
  775.  {50.0f,14.2857f},
  776.  {54.7619f,14.2857f},
  777.  {69.0476f,19.0476f}
  778. };
  779. static const SFG_StrokeStrip ch64st[] =
  780. {
  781.  {8,ch64st0},
  782.  {19,ch64st1}
  783. };
  784. static const SFG_StrokeChar ch64 = {104.762f,2,ch64st};
  785. /* char: 0x41 */
  786. static const SFG_StrokeVertex ch65st0[] =
  787. {
  788.  {52.3809f,100.0f},
  789.  {14.2857f,0.0f}
  790. };
  791. static const SFG_StrokeVertex ch65st1[] =
  792. {
  793.  {52.3809f,100.0f},
  794.  {90.4762f,0.0f}
  795. };
  796. static const SFG_StrokeVertex ch65st2[] =
  797. {
  798.  {28.5714f,33.3333f},
  799.  {76.1905f,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 = {104.762f,3,ch65st};
  808. /* char: 0x42 */
  809. static const SFG_StrokeVertex ch66st0[] =
  810. {
  811.  {19.0476f,100.0f},
  812.  {19.0476f,0.0f}
  813. };
  814. static const SFG_StrokeVertex ch66st1[] =
  815. {
  816.  {19.0476f,100.0f},
  817.  {61.9047f,100.0f},
  818.  {76.1905f,95.2381f},
  819.  {80.9524f,90.4762f},
  820.  {85.7143f,80.9524f},
  821.  {85.7143f,71.4286f},
  822.  {80.9524f,61.9048f},
  823.  {76.1905f,57.1429f},
  824.  {61.9047f,52.381f}
  825. };
  826. static const SFG_StrokeVertex ch66st2[] =
  827. {
  828.  {19.0476f,52.381f},
  829.  {61.9047f,52.381f},
  830.  {76.1905f,47.619f},
  831.  {80.9524f,42.8571f},
  832.  {85.7143f,33.3333f},
  833.  {85.7143f,19.0476f},
  834.  {80.9524f,9.5238f},
  835.  {76.1905f,4.7619f},
  836.  {61.9047f,0.0f},
  837.  {19.0476f,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 = {104.762f,3,ch66st};
  846. /* char: 0x43 */
  847. static const SFG_StrokeVertex ch67st0[] =
  848. {
  849.  {88.0952f,76.1905f},
  850.  {83.3334f,85.7143f},
  851.  {73.8096f,95.2381f},
  852.  {64.2857f,100.0f},
  853.  {45.2381f,100.0f},
  854.  {35.7143f,95.2381f},
  855.  {26.1905f,85.7143f},
  856.  {21.4286f,76.1905f},
  857.  {16.6667f,61.9048f},
  858.  {16.6667f,38.0952f},
  859.  {21.4286f,23.8095f},
  860.  {26.1905f,14.2857f},
  861.  {35.7143f,4.7619f},
  862.  {45.2381f,0.0f},
  863.  {64.2857f,0.0f},
  864.  {73.8096f,4.7619f},
  865.  {83.3334f,14.2857f},
  866.  {88.0952f,23.8095f}
  867. };
  868. static const SFG_StrokeStrip ch67st[] =
  869. {
  870.  {18,ch67st0}
  871. };
  872. static const SFG_StrokeChar ch67 = {104.762f,1,ch67st};
  873. /* char: 0x44 */
  874. static const SFG_StrokeVertex ch68st0[] =
  875. {
  876.  {19.0476f,100.0f},
  877.  {19.0476f,0.0f}
  878. };
  879. static const SFG_StrokeVertex ch68st1[] =
  880. {
  881.  {19.0476f,100.0f},
  882.  {52.3809f,100.0f},
  883.  {66.6666f,95.2381f},
  884.  {76.1905f,85.7143f},
  885.  {80.9524f,76.1905f},
  886.  {85.7143f,61.9048f},
  887.  {85.7143f,38.0952f},
  888.  {80.9524f,23.8095f},
  889.  {76.1905f,14.2857f},
  890.  {66.6666f,4.7619f},
  891.  {52.3809f,0.0f},
  892.  {19.0476f,0.0f}
  893. };
  894. static const SFG_StrokeStrip ch68st[] =
  895. {
  896.  {2,ch68st0},
  897.  {12,ch68st1}
  898. };
  899. static const SFG_StrokeChar ch68 = {104.762f,2,ch68st};
  900. /* char: 0x45 */
  901. static const SFG_StrokeVertex ch69st0[] =
  902. {
  903.  {21.4286f,100.0f},
  904.  {21.4286f,0.0f}
  905. };
  906. static const SFG_StrokeVertex ch69st1[] =
  907. {
  908.  {21.4286f,100.0f},
  909.  {83.3334f,100.0f}
  910. };
  911. static const SFG_StrokeVertex ch69st2[] =
  912. {
  913.  {21.4286f,52.381f},
  914.  {59.5238f,52.381f}
  915. };
  916. static const SFG_StrokeVertex ch69st3[] =
  917. {
  918.  {21.4286f,0.0f},
  919.  {83.3334f,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 = {104.762f,4,ch69st};
  929. /* char: 0x46 */
  930. static const SFG_StrokeVertex ch70st0[] =
  931. {
  932.  {21.4286f,100.0f},
  933.  {21.4286f,0.0f}
  934. };
  935. static const SFG_StrokeVertex ch70st1[] =
  936. {
  937.  {21.4286f,100.0f},
  938.  {83.3334f,100.0f}
  939. };
  940. static const SFG_StrokeVertex ch70st2[] =
  941. {
  942.  {21.4286f,52.381f},
  943.  {59.5238f,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 = {104.762f,3,ch70st};
  952. /* char: 0x47 */
  953. static const SFG_StrokeVertex ch71st0[] =
  954. {
  955.  {88.0952f,76.1905f},
  956.  {83.3334f,85.7143f},
  957.  {73.8096f,95.2381f},
  958.  {64.2857f,100.0f},
  959.  {45.2381f,100.0f},
  960.  {35.7143f,95.2381f},
  961.  {26.1905f,85.7143f},
  962.  {21.4286f,76.1905f},
  963.  {16.6667f,61.9048f},
  964.  {16.6667f,38.0952f},
  965.  {21.4286f,23.8095f},
  966.  {26.1905f,14.2857f},
  967.  {35.7143f,4.7619f},
  968.  {45.2381f,0.0f},
  969.  {64.2857f,0.0f},
  970.  {73.8096f,4.7619f},
  971.  {83.3334f,14.2857f},
  972.  {88.0952f,23.8095f},
  973.  {88.0952f,38.0952f}
  974. };
  975. static const SFG_StrokeVertex ch71st1[] =
  976. {
  977.  {64.2857f,38.0952f},
  978.  {88.0952f,38.0952f}
  979. };
  980. static const SFG_StrokeStrip ch71st[] =
  981. {
  982.  {19,ch71st0},
  983.  {2,ch71st1}
  984. };
  985. static const SFG_StrokeChar ch71 = {104.762f,2,ch71st};
  986. /* char: 0x48 */
  987. static const SFG_StrokeVertex ch72st0[] =
  988. {
  989.  {19.0476f,100.0f},
  990.  {19.0476f,0.0f}
  991. };
  992. static const SFG_StrokeVertex ch72st1[] =
  993. {
  994.  {85.7143f,100.0f},
  995.  {85.7143f,0.0f}
  996. };
  997. static const SFG_StrokeVertex ch72st2[] =
  998. {
  999.  {19.0476f,52.381f},
  1000.  {85.7143f,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 = {104.762f,3,ch72st};
  1009. /* char: 0x49 */
  1010. static const SFG_StrokeVertex ch73st0[] =
  1011. {
  1012.  {52.381f,100.0f},
  1013.  {52.381f,0.0f}
  1014. };
  1015. static const SFG_StrokeStrip ch73st[] =
  1016. {
  1017.  {2,ch73st0}
  1018. };
  1019. static const SFG_StrokeChar ch73 = {104.762f,1,ch73st};
  1020. /* char: 0x4a */
  1021. static const SFG_StrokeVertex ch74st0[] =
  1022. {
  1023.  {76.1905f,100.0f},
  1024.  {76.1905f,23.8095f},
  1025.  {71.4286f,9.5238f},
  1026.  {66.6667f,4.7619f},
  1027.  {57.1429f,0.0f},
  1028.  {47.6191f,0.0f},
  1029.  {38.0953f,4.7619f},
  1030.  {33.3334f,9.5238f},
  1031.  {28.5715f,23.8095f},
  1032.  {28.5715f,33.3333f}
  1033. };
  1034. static const SFG_StrokeStrip ch74st[] =
  1035. {
  1036.  {10,ch74st0}
  1037. };
  1038. static const SFG_StrokeChar ch74 = {104.762f,1,ch74st};
  1039. /* char: 0x4b */
  1040. static const SFG_StrokeVertex ch75st0[] =
  1041. {
  1042.  {19.0476f,100.0f},
  1043.  {19.0476f,0.0f}
  1044. };
  1045. static const SFG_StrokeVertex ch75st1[] =
  1046. {
  1047.  {85.7143f,100.0f},
  1048.  {19.0476f,33.3333f}
  1049. };
  1050. static const SFG_StrokeVertex ch75st2[] =
  1051. {
  1052.  {42.8571f,57.1429f},
  1053.  {85.7143f,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 = {104.762f,3,ch75st};
  1062. /* char: 0x4c */
  1063. static const SFG_StrokeVertex ch76st0[] =
  1064. {
  1065.  {23.8095f,100.0f},
  1066.  {23.8095f,0.0f}
  1067. };
  1068. static const SFG_StrokeVertex ch76st1[] =
  1069. {
  1070.  {23.8095f,0.0f},
  1071.  {80.9524f,0.0f}
  1072. };
  1073. static const SFG_StrokeStrip ch76st[] =
  1074. {
  1075.  {2,ch76st0},
  1076.  {2,ch76st1}
  1077. };
  1078. static const SFG_StrokeChar ch76 = {104.762f,2,ch76st};
  1079. /* char: 0x4d */
  1080. static const SFG_StrokeVertex ch77st0[] =
  1081. {
  1082.  {14.2857f,100.0f},
  1083.  {14.2857f,0.0f}
  1084. };
  1085. static const SFG_StrokeVertex ch77st1[] =
  1086. {
  1087.  {14.2857f,100.0f},
  1088.  {52.3809f,0.0f}
  1089. };
  1090. static const SFG_StrokeVertex ch77st2[] =
  1091. {
  1092.  {90.4762f,100.0f},
  1093.  {52.3809f,0.0f}
  1094. };
  1095. static const SFG_StrokeVertex ch77st3[] =
  1096. {
  1097.  {90.4762f,100.0f},
  1098.  {90.4762f,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 = {104.762f,4,ch77st};
  1108. /* char: 0x4e */
  1109. static const SFG_StrokeVertex ch78st0[] =
  1110. {
  1111.  {19.0476f,100.0f},
  1112.  {19.0476f,0.0f}
  1113. };
  1114. static const SFG_StrokeVertex ch78st1[] =
  1115. {
  1116.  {19.0476f,100.0f},
  1117.  {85.7143f,0.0f}
  1118. };
  1119. static const SFG_StrokeVertex ch78st2[] =
  1120. {
  1121.  {85.7143f,100.0f},
  1122.  {85.7143f,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 = {104.762f,3,ch78st};
  1131. /* char: 0x4f */
  1132. static const SFG_StrokeVertex ch79st0[] =
  1133. {
  1134.  {42.8571f,100.0f},
  1135.  {33.3333f,95.2381f},
  1136.  {23.8095f,85.7143f},
  1137.  {19.0476f,76.1905f},
  1138.  {14.2857f,61.9048f},
  1139.  {14.2857f,38.0952f},
  1140.  {19.0476f,23.8095f},
  1141.  {23.8095f,14.2857f},
  1142.  {33.3333f,4.7619f},
  1143.  {42.8571f,0.0f},
  1144.  {61.9047f,0.0f},
  1145.  {71.4286f,4.7619f},
  1146.  {80.9524f,14.2857f},
  1147.  {85.7143f,23.8095f},
  1148.  {90.4762f,38.0952f},
  1149.  {90.4762f,61.9048f},
  1150.  {85.7143f,76.1905f},
  1151.  {80.9524f,85.7143f},
  1152.  {71.4286f,95.2381f},
  1153.  {61.9047f,100.0f},
  1154.  {42.8571f,100.0f}
  1155. };
  1156. static const SFG_StrokeStrip ch79st[] =
  1157. {
  1158.  {21,ch79st0}
  1159. };
  1160. static const SFG_StrokeChar ch79 = {104.762f,1,ch79st};
  1161. /* char: 0x50 */
  1162. static const SFG_StrokeVertex ch80st0[] =
  1163. {
  1164.  {19.0476f,100.0f},
  1165.  {19.0476f,0.0f}
  1166. };
  1167. static const SFG_StrokeVertex ch80st1[] =
  1168. {
  1169.  {19.0476f,100.0f},
  1170.  {61.9047f,100.0f},
  1171.  {76.1905f,95.2381f},
  1172.  {80.9524f,90.4762f},
  1173.  {85.7143f,80.9524f},
  1174.  {85.7143f,66.6667f},
  1175.  {80.9524f,57.1429f},
  1176.  {76.1905f,52.381f},
  1177.  {61.9047f,47.619f},
  1178.  {19.0476f,47.619f}
  1179. };
  1180. static const SFG_StrokeStrip ch80st[] =
  1181. {
  1182.  {2,ch80st0},
  1183.  {10,ch80st1}
  1184. };
  1185. static const SFG_StrokeChar ch80 = {104.762f,2,ch80st};
  1186. /* char: 0x51 */
  1187. static const SFG_StrokeVertex ch81st0[] =
  1188. {
  1189.  {42.8571f,100.0f},
  1190.  {33.3333f,95.2381f},
  1191.  {23.8095f,85.7143f},
  1192.  {19.0476f,76.1905f},
  1193.  {14.2857f,61.9048f},
  1194.  {14.2857f,38.0952f},
  1195.  {19.0476f,23.8095f},
  1196.  {23.8095f,14.2857f},
  1197.  {33.3333f,4.7619f},
  1198.  {42.8571f,0.0f},
  1199.  {61.9047f,0.0f},
  1200.  {71.4286f,4.7619f},
  1201.  {80.9524f,14.2857f},
  1202.  {85.7143f,23.8095f},
  1203.  {90.4762f,38.0952f},
  1204.  {90.4762f,61.9048f},
  1205.  {85.7143f,76.1905f},
  1206.  {80.9524f,85.7143f},
  1207.  {71.4286f,95.2381f},
  1208.  {61.9047f,100.0f},
  1209.  {42.8571f,100.0f}
  1210. };
  1211. static const SFG_StrokeVertex ch81st1[] =
  1212. {
  1213.  {57.1428f,19.0476f},
  1214.  {85.7143f,-9.5238f}
  1215. };
  1216. static const SFG_StrokeStrip ch81st[] =
  1217. {
  1218.  {21,ch81st0},
  1219.  {2,ch81st1}
  1220. };
  1221. static const SFG_StrokeChar ch81 = {104.762f,2,ch81st};
  1222. /* char: 0x52 */
  1223. static const SFG_StrokeVertex ch82st0[] =
  1224. {
  1225.  {19.0476f,100.0f},
  1226.  {19.0476f,0.0f}
  1227. };
  1228. static const SFG_StrokeVertex ch82st1[] =
  1229. {
  1230.  {19.0476f,100.0f},
  1231.  {61.9047f,100.0f},
  1232.  {76.1905f,95.2381f},
  1233.  {80.9524f,90.4762f},
  1234.  {85.7143f,80.9524f},
  1235.  {85.7143f,71.4286f},
  1236.  {80.9524f,61.9048f},
  1237.  {76.1905f,57.1429f},
  1238.  {61.9047f,52.381f},
  1239.  {19.0476f,52.381f}
  1240. };
  1241. static const SFG_StrokeVertex ch82st2[] =
  1242. {
  1243.  {52.3809f,52.381f},
  1244.  {85.7143f,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 = {104.762f,3,ch82st};
  1253. /* char: 0x53 */
  1254. static const SFG_StrokeVertex ch83st0[] =
  1255. {
  1256.  {85.7143f,85.7143f},
  1257.  {76.1905f,95.2381f},
  1258.  {61.9047f,100.0f},
  1259.  {42.8571f,100.0f},
  1260.  {28.5714f,95.2381f},
  1261.  {19.0476f,85.7143f},
  1262.  {19.0476f,76.1905f},
  1263.  {23.8095f,66.6667f},
  1264.  {28.5714f,61.9048f},
  1265.  {38.0952f,57.1429f},
  1266.  {66.6666f,47.619f},
  1267.  {76.1905f,42.8571f},
  1268.  {80.9524f,38.0952f},
  1269.  {85.7143f,28.5714f},
  1270.  {85.7143f,14.2857f},
  1271.  {76.1905f,4.7619f},
  1272.  {61.9047f,0.0f},
  1273.  {42.8571f,0.0f},
  1274.  {28.5714f,4.7619f},
  1275.  {19.0476f,14.2857f}
  1276. };
  1277. static const SFG_StrokeStrip ch83st[] =
  1278. {
  1279.  {20,ch83st0}
  1280. };
  1281. static const SFG_StrokeChar ch83 = {104.762f,1,ch83st};
  1282. /* char: 0x54 */
  1283. static const SFG_StrokeVertex ch84st0[] =
  1284. {
  1285.  {52.3809f,100.0f},
  1286.  {52.3809f,0.0f}
  1287. };
  1288. static const SFG_StrokeVertex ch84st1[] =
  1289. {
  1290.  {19.0476f,100.0f},
  1291.  {85.7143f,100.0f}
  1292. };
  1293. static const SFG_StrokeStrip ch84st[] =
  1294. {
  1295.  {2,ch84st0},
  1296.  {2,ch84st1}
  1297. };
  1298. static const SFG_StrokeChar ch84 = {104.762f,2,ch84st};
  1299. /* char: 0x55 */
  1300. static const SFG_StrokeVertex ch85st0[] =
  1301. {
  1302.  {19.0476f,100.0f},
  1303.  {19.0476f,28.5714f},
  1304.  {23.8095f,14.2857f},
  1305.  {33.3333f,4.7619f},
  1306.  {47.619f,0.0f},
  1307.  {57.1428f,0.0f},
  1308.  {71.4286f,4.7619f},
  1309.  {80.9524f,14.2857f},
  1310.  {85.7143f,28.5714f},
  1311.  {85.7143f,100.0f}
  1312. };
  1313. static const SFG_StrokeStrip ch85st[] =
  1314. {
  1315.  {10,ch85st0}
  1316. };
  1317. static const SFG_StrokeChar ch85 = {104.762f,1,ch85st};
  1318. /* char: 0x56 */
  1319. static const SFG_StrokeVertex ch86st0[] =
  1320. {
  1321.  {14.2857f,100.0f},
  1322.  {52.3809f,0.0f}
  1323. };
  1324. static const SFG_StrokeVertex ch86st1[] =
  1325. {
  1326.  {90.4762f,100.0f},
  1327.  {52.3809f,0.0f}
  1328. };
  1329. static const SFG_StrokeStrip ch86st[] =
  1330. {
  1331.  {2,ch86st0},
  1332.  {2,ch86st1}
  1333. };
  1334. static const SFG_StrokeChar ch86 = {104.762f,2,ch86st};
  1335. /* char: 0x57 */
  1336. static const SFG_StrokeVertex ch87st0[] =
  1337. {
  1338.  {4.7619f,100.0f},
  1339.  {28.5714f,0.0f}
  1340. };
  1341. static const SFG_StrokeVertex ch87st1[] =
  1342. {
  1343.  {52.3809f,100.0f},
  1344.  {28.5714f,0.0f}
  1345. };
  1346. static const SFG_StrokeVertex ch87st2[] =
  1347. {
  1348.  {52.3809f,100.0f},
  1349.  {76.1905f,0.0f}
  1350. };
  1351. static const SFG_StrokeVertex ch87st3[] =
  1352. {
  1353.  {100.0f,100.0f},
  1354.  {76.1905f,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 = {104.762f,4,ch87st};
  1364. /* char: 0x58 */
  1365. static const SFG_StrokeVertex ch88st0[] =
  1366. {
  1367.  {19.0476f,100.0f},
  1368.  {85.7143f,0.0f}
  1369. };
  1370. static const SFG_StrokeVertex ch88st1[] =
  1371. {
  1372.  {85.7143f,100.0f},
  1373.  {19.0476f,0.0f}
  1374. };
  1375. static const SFG_StrokeStrip ch88st[] =
  1376. {
  1377.  {2,ch88st0},
  1378.  {2,ch88st1}
  1379. };
  1380. static const SFG_StrokeChar ch88 = {104.762f,2,ch88st};
  1381. /* char: 0x59 */
  1382. static const SFG_StrokeVertex ch89st0[] =
  1383. {
  1384.  {14.2857f,100.0f},
  1385.  {52.3809f,52.381f},
  1386.  {52.3809f,0.0f}
  1387. };
  1388. static const SFG_StrokeVertex ch89st1[] =
  1389. {
  1390.  {90.4762f,100.0f},
  1391.  {52.3809f,52.381f}
  1392. };
  1393. static const SFG_StrokeStrip ch89st[] =
  1394. {
  1395.  {3,ch89st0},
  1396.  {2,ch89st1}
  1397. };
  1398. static const SFG_StrokeChar ch89 = {104.762f,2,ch89st};
  1399. /* char: 0x5a */
  1400. static const SFG_StrokeVertex ch90st0[] =
  1401. {
  1402.  {85.7143f,100.0f},
  1403.  {19.0476f,0.0f}
  1404. };
  1405. static const SFG_StrokeVertex ch90st1[] =
  1406. {
  1407.  {19.0476f,100.0f},
  1408.  {85.7143f,100.0f}
  1409. };
  1410. static const SFG_StrokeVertex ch90st2[] =
  1411. {
  1412.  {19.0476f,0.0f},
  1413.  {85.7143f,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 = {104.762f,3,ch90st};
  1422. /* char: 0x5b */
  1423. static const SFG_StrokeVertex ch91st0[] =
  1424. {
  1425.  {35.7143f,119.048f},
  1426.  {35.7143f,-33.3333f}
  1427. };
  1428. static const SFG_StrokeVertex ch91st1[] =
  1429. {
  1430.  {40.4762f,119.048f},
  1431.  {40.4762f,-33.3333f}
  1432. };
  1433. static const SFG_StrokeVertex ch91st2[] =
  1434. {
  1435.  {35.7143f,119.048f},
  1436.  {69.0476f,119.048f}
  1437. };
  1438. static const SFG_StrokeVertex ch91st3[] =
  1439. {
  1440.  {35.7143f,-33.3333f},
  1441.  {69.0476f,-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 = {104.762f,4,ch91st};
  1451. /* char: 0x5c */
  1452. static const SFG_StrokeVertex ch92st0[] =
  1453. {
  1454.  {19.0476f,100.0f},
  1455.  {85.7143f,-14.2857f}
  1456. };
  1457. static const SFG_StrokeStrip ch92st[] =
  1458. {
  1459.  {2,ch92st0}
  1460. };
  1461. static const SFG_StrokeChar ch92 = {104.762f,1,ch92st};
  1462. /* char: 0x5d */
  1463. static const SFG_StrokeVertex ch93st0[] =
  1464. {
  1465.  {64.2857f,119.048f},
  1466.  {64.2857f,-33.3333f}
  1467. };
  1468. static const SFG_StrokeVertex ch93st1[] =
  1469. {
  1470.  {69.0476f,119.048f},
  1471.  {69.0476f,-33.3333f}
  1472. };
  1473. static const SFG_StrokeVertex ch93st2[] =
  1474. {
  1475.  {35.7143f,119.048f},
  1476.  {69.0476f,119.048f}
  1477. };
  1478. static const SFG_StrokeVertex ch93st3[] =
  1479. {
  1480.  {35.7143f,-33.3333f},
  1481.  {69.0476f,-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 = {104.762f,4,ch93st};
  1491. /* char: 0x5e */
  1492. static const SFG_StrokeVertex ch94st0[] =
  1493. {
  1494.  {52.3809f,109.524f},
  1495.  {14.2857f,42.8571f}
  1496. };
  1497. static const SFG_StrokeVertex ch94st1[] =
  1498. {
  1499.  {52.3809f,109.524f},
  1500.  {90.4762f,42.8571f}
  1501. };
  1502. static const SFG_StrokeStrip ch94st[] =
  1503. {
  1504.  {2,ch94st0},
  1505.  {2,ch94st1}
  1506. };
  1507. static const SFG_StrokeChar ch94 = {104.762f,2,ch94st};
  1508. /* char: 0x5f */
  1509. static const SFG_StrokeVertex ch95st0[] =
  1510. {
  1511.  {0,-33.3333f},
  1512.  {104.762f,-33.3333f},
  1513.  {104.762f,-28.5714f},
  1514.  {0,-28.5714f},
  1515.  {0,-33.3333f}
  1516. };
  1517. static const SFG_StrokeStrip ch95st[] =
  1518. {
  1519.  {5,ch95st0}
  1520. };
  1521. static const SFG_StrokeChar ch95 = {104.762f,1,ch95st};
  1522. /* char: 0x60 */
  1523. static const SFG_StrokeVertex ch96st0[] =
  1524. {
  1525.  {42.8572f,100.0f},
  1526.  {66.6667f,71.4286f}
  1527. };
  1528. static const SFG_StrokeVertex ch96st1[] =
  1529. {
  1530.  {42.8572f,100.0f},
  1531.  {38.0953f,95.2381f},
  1532.  {66.6667f,71.4286f}
  1533. };
  1534. static const SFG_StrokeStrip ch96st[] =
  1535. {
  1536.  {2,ch96st0},
  1537.  {3,ch96st1}
  1538. };
  1539. static const SFG_StrokeChar ch96 = {104.762f,2,ch96st};
  1540. /* char: 0x61 */
  1541. static const SFG_StrokeVertex ch97st0[] =
  1542. {
  1543.  {80.9524f,66.6667f},
  1544.  {80.9524f,0.0f}
  1545. };
  1546. static const SFG_StrokeVertex ch97st1[] =
  1547. {
  1548.  {80.9524f,52.381f},
  1549.  {71.4285f,61.9048f},
  1550.  {61.9047f,66.6667f},
  1551.  {47.619f,66.6667f},
  1552.  {38.0952f,61.9048f},
  1553.  {28.5714f,52.381f},
  1554.  {23.8095f,38.0952f},
  1555.  {23.8095f,28.5714f},
  1556.  {28.5714f,14.2857f},
  1557.  {38.0952f,4.7619f},
  1558.  {47.619f,0.0f},
  1559.  {61.9047f,0.0f},
  1560.  {71.4285f,4.7619f},
  1561.  {80.9524f,14.2857f}
  1562. };
  1563. static const SFG_StrokeStrip ch97st[] =
  1564. {
  1565.  {2,ch97st0},
  1566.  {14,ch97st1}
  1567. };
  1568. static const SFG_StrokeChar ch97 = {104.762f,2,ch97st};
  1569. /* char: 0x62 */
  1570. static const SFG_StrokeVertex ch98st0[] =
  1571. {
  1572.  {23.8095f,100.0f},
  1573.  {23.8095f,0.0f}
  1574. };
  1575. static const SFG_StrokeVertex ch98st1[] =
  1576. {
  1577.  {23.8095f,52.381f},
  1578.  {33.3333f,61.9048f},
  1579.  {42.8571f,66.6667f},
  1580.  {57.1428f,66.6667f},
  1581.  {66.6666f,61.9048f},
  1582.  {76.1905f,52.381f},
  1583.  {80.9524f,38.0952f},
  1584.  {80.9524f,28.5714f},
  1585.  {76.1905f,14.2857f},
  1586.  {66.6666f,4.7619f},
  1587.  {57.1428f,0.0f},
  1588.  {42.8571f,0.0f},
  1589.  {33.3333f,4.7619f},
  1590.  {23.8095f,14.2857f}
  1591. };
  1592. static const SFG_StrokeStrip ch98st[] =
  1593. {
  1594.  {2,ch98st0},
  1595.  {14,ch98st1}
  1596. };
  1597. static const SFG_StrokeChar ch98 = {104.762f,2,ch98st};
  1598. /* char: 0x63 */
  1599. static const SFG_StrokeVertex ch99st0[] =
  1600. {
  1601.  {80.9524f,52.381f},
  1602.  {71.4285f,61.9048f},
  1603.  {61.9047f,66.6667f},
  1604.  {47.619f,66.6667f},
  1605.  {38.0952f,61.9048f},
  1606.  {28.5714f,52.381f},
  1607.  {23.8095f,38.0952f},
  1608.  {23.8095f,28.5714f},
  1609.  {28.5714f,14.2857f},
  1610.  {38.0952f,4.7619f},
  1611.  {47.619f,0.0f},
  1612.  {61.9047f,0.0f},
  1613.  {71.4285f,4.7619f},
  1614.  {80.9524f,14.2857f}
  1615. };
  1616. static const SFG_StrokeStrip ch99st[] =
  1617. {
  1618.  {14,ch99st0}
  1619. };
  1620. static const SFG_StrokeChar ch99 = {104.762f,1,ch99st};
  1621. /* char: 0x64 */
  1622. static const SFG_StrokeVertex ch100st0[] =
  1623. {
  1624.  {80.9524f,100.0f},
  1625.  {80.9524f,0.0f}
  1626. };
  1627. static const SFG_StrokeVertex ch100st1[] =
  1628. {
  1629.  {80.9524f,52.381f},
  1630.  {71.4285f,61.9048f},
  1631.  {61.9047f,66.6667f},
  1632.  {47.619f,66.6667f},
  1633.  {38.0952f,61.9048f},
  1634.  {28.5714f,52.381f},
  1635.  {23.8095f,38.0952f},
  1636.  {23.8095f,28.5714f},
  1637.  {28.5714f,14.2857f},
  1638.  {38.0952f,4.7619f},
  1639.  {47.619f,0.0f},
  1640.  {61.9047f,0.0f},
  1641.  {71.4285f,4.7619f},
  1642.  {80.9524f,14.2857f}
  1643. };
  1644. static const SFG_StrokeStrip ch100st[] =
  1645. {
  1646.  {2,ch100st0},
  1647.  {14,ch100st1}
  1648. };
  1649. static const SFG_StrokeChar ch100 = {104.762f,2,ch100st};
  1650. /* char: 0x65 */
  1651. static const SFG_StrokeVertex ch101st0[] =
  1652. {
  1653.  {23.8095f,38.0952f},
  1654.  {80.9524f,38.0952f},
  1655.  {80.9524f,47.619f},
  1656.  {76.1905f,57.1429f},
  1657.  {71.4285f,61.9048f},
  1658.  {61.9047f,66.6667f},
  1659.  {47.619f,66.6667f},
  1660.  {38.0952f,61.9048f},
  1661.  {28.5714f,52.381f},
  1662.  {23.8095f,38.0952f},
  1663.  {23.8095f,28.5714f},
  1664.  {28.5714f,14.2857f},
  1665.  {38.0952f,4.7619f},
  1666.  {47.619f,0.0f},
  1667.  {61.9047f,0.0f},
  1668.  {71.4285f,4.7619f},
  1669.  {80.9524f,14.2857f}
  1670. };
  1671. static const SFG_StrokeStrip ch101st[] =
  1672. {
  1673.  {17,ch101st0}
  1674. };
  1675. static const SFG_StrokeChar ch101 = {104.762f,1,ch101st};
  1676. /* char: 0x66 */
  1677. static const SFG_StrokeVertex ch102st0[] =
  1678. {
  1679.  {71.4286f,100.0f},
  1680.  {61.9048f,100.0f},
  1681.  {52.381f,95.2381f},
  1682.  {47.6191f,80.9524f},
  1683.  {47.6191f,0.0f}
  1684. };
  1685. static const SFG_StrokeVertex ch102st1[] =
  1686. {
  1687.  {33.3334f,66.6667f},
  1688.  {66.6667f,66.6667f}
  1689. };
  1690. static const SFG_StrokeStrip ch102st[] =
  1691. {
  1692.  {5,ch102st0},
  1693.  {2,ch102st1}
  1694. };
  1695. static const SFG_StrokeChar ch102 = {104.762f,2,ch102st};
  1696. /* char: 0x67 */
  1697. static const SFG_StrokeVertex ch103st0[] =
  1698. {
  1699.  {80.9524f,66.6667f},
  1700.  {80.9524f,-9.5238f},
  1701.  {76.1905f,-23.8095f},
  1702.  {71.4285f,-28.5714f},
  1703.  {61.9047f,-33.3333f},
  1704.  {47.619f,-33.3333f},
  1705.  {38.0952f,-28.5714f}
  1706. };
  1707. static const SFG_StrokeVertex ch103st1[] =
  1708. {
  1709.  {80.9524f,52.381f},
  1710.  {71.4285f,61.9048f},
  1711.  {61.9047f,66.6667f},
  1712.  {47.619f,66.6667f},
  1713.  {38.0952f,61.9048f},
  1714.  {28.5714f,52.381f},
  1715.  {23.8095f,38.0952f},
  1716.  {23.8095f,28.5714f},
  1717.  {28.5714f,14.2857f},
  1718.  {38.0952f,4.7619f},
  1719.  {47.619f,0.0f},
  1720.  {61.9047f,0.0f},
  1721.  {71.4285f,4.7619f},
  1722.  {80.9524f,14.2857f}
  1723. };
  1724. static const SFG_StrokeStrip ch103st[] =
  1725. {
  1726.  {7,ch103st0},
  1727.  {14,ch103st1}
  1728. };
  1729. static const SFG_StrokeChar ch103 = {104.762f,2,ch103st};
  1730. /* char: 0x68 */
  1731. static const SFG_StrokeVertex ch104st0[] =
  1732. {
  1733.  {26.1905f,100.0f},
  1734.  {26.1905f,0.0f}
  1735. };
  1736. static const SFG_StrokeVertex ch104st1[] =
  1737. {
  1738.  {26.1905f,47.619f},
  1739.  {40.4762f,61.9048f},
  1740.  {50.0f,66.6667f},
  1741.  {64.2857f,66.6667f},
  1742.  {73.8095f,61.9048f},
  1743.  {78.5715f,47.619f},
  1744.  {78.5715f,0.0f}
  1745. };
  1746. static const SFG_StrokeStrip ch104st[] =
  1747. {
  1748.  {2,ch104st0},
  1749.  {7,ch104st1}
  1750. };
  1751. static const SFG_StrokeChar ch104 = {104.762f,2,ch104st};
  1752. /* char: 0x69 */
  1753. static const SFG_StrokeVertex ch105st0[] =
  1754. {
  1755.  {47.6191f,100.0f},
  1756.  {52.381f,95.2381f},
  1757.  {57.1429f,100.0f},
  1758.  {52.381f,104.762f},
  1759.  {47.6191f,100.0f}
  1760. };
  1761. static const SFG_StrokeVertex ch105st1[] =
  1762. {
  1763.  {52.381f,66.6667f},
  1764.  {52.381f,0.0f}
  1765. };
  1766. static const SFG_StrokeStrip ch105st[] =
  1767. {
  1768.  {5,ch105st0},
  1769.  {2,ch105st1}
  1770. };
  1771. static const SFG_StrokeChar ch105 = {104.762f,2,ch105st};
  1772. /* char: 0x6a */
  1773. static const SFG_StrokeVertex ch106st0[] =
  1774. {
  1775.  {57.1429f,100.0f},
  1776.  {61.9048f,95.2381f},
  1777.  {66.6667f,100.0f},
  1778.  {61.9048f,104.762f},
  1779.  {57.1429f,100.0f}
  1780. };
  1781. static const SFG_StrokeVertex ch106st1[] =
  1782. {
  1783.  {61.9048f,66.6667f},
  1784.  {61.9048f,-14.2857f},
  1785.  {57.1429f,-28.5714f},
  1786.  {47.6191f,-33.3333f},
  1787.  {38.0953f,-33.3333f}
  1788. };
  1789. static const SFG_StrokeStrip ch106st[] =
  1790. {
  1791.  {5,ch106st0},
  1792.  {5,ch106st1}
  1793. };
  1794. static const SFG_StrokeChar ch106 = {104.762f,2,ch106st};
  1795. /* char: 0x6b */
  1796. static const SFG_StrokeVertex ch107st0[] =
  1797. {
  1798.  {26.1905f,100.0f},
  1799.  {26.1905f,0.0f}
  1800. };
  1801. static const SFG_StrokeVertex ch107st1[] =
  1802. {
  1803.  {73.8095f,66.6667f},
  1804.  {26.1905f,19.0476f}
  1805. };
  1806. static const SFG_StrokeVertex ch107st2[] =
  1807. {
  1808.  {45.2381f,38.0952f},
  1809.  {78.5715f,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 = {104.762f,3,ch107st};
  1818. /* char: 0x6c */
  1819. static const SFG_StrokeVertex ch108st0[] =
  1820. {
  1821.  {52.381f,100.0f},
  1822.  {52.381f,0.0f}
  1823. };
  1824. static const SFG_StrokeStrip ch108st[] =
  1825. {
  1826.  {2,ch108st0}
  1827. };
  1828. static const SFG_StrokeChar ch108 = {104.762f,1,ch108st};
  1829. /* char: 0x6d */
  1830. static const SFG_StrokeVertex ch109st0[] =
  1831. {
  1832.  {0,66.6667f},
  1833.  {0,0.0f}
  1834. };
  1835. static const SFG_StrokeVertex ch109st1[] =
  1836. {
  1837.  {0,47.619f},
  1838.  {14.2857f,61.9048f},
  1839.  {23.8095f,66.6667f},
  1840.  {38.0952f,66.6667f},
  1841.  {47.619f,61.9048f},
  1842.  {52.381f,47.619f},
  1843.  {52.381f,0.0f}
  1844. };
  1845. static const SFG_StrokeVertex ch109st2[] =
  1846. {
  1847.  {52.381f,47.619f},
  1848.  {66.6667f,61.9048f},
  1849.  {76.1905f,66.6667f},
  1850.  {90.4762f,66.6667f},
  1851.  {100.0f,61.9048f},
  1852.  {104.762f,47.619f},
  1853.  {104.762f,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 = {104.762f,3,ch109st};
  1862. /* char: 0x6e */
  1863. static const SFG_StrokeVertex ch110st0[] =
  1864. {
  1865.  {26.1905f,66.6667f},
  1866.  {26.1905f,0.0f}
  1867. };
  1868. static const SFG_StrokeVertex ch110st1[] =
  1869. {
  1870.  {26.1905f,47.619f},
  1871.  {40.4762f,61.9048f},
  1872.  {50.0f,66.6667f},
  1873.  {64.2857f,66.6667f},
  1874.  {73.8095f,61.9048f},
  1875.  {78.5715f,47.619f},
  1876.  {78.5715f,0.0f}
  1877. };
  1878. static const SFG_StrokeStrip ch110st[] =
  1879. {
  1880.  {2,ch110st0},
  1881.  {7,ch110st1}
  1882. };
  1883. static const SFG_StrokeChar ch110 = {104.762f,2,ch110st};
  1884. /* char: 0x6f */
  1885. static const SFG_StrokeVertex ch111st0[] =
  1886. {
  1887.  {45.2381f,66.6667f},
  1888.  {35.7143f,61.9048f},
  1889.  {26.1905f,52.381f},
  1890.  {21.4286f,38.0952f},
  1891.  {21.4286f,28.5714f},
  1892.  {26.1905f,14.2857f},
  1893.  {35.7143f,4.7619f},
  1894.  {45.2381f,0.0f},
  1895.  {59.5238f,0.0f},
  1896.  {69.0476f,4.7619f},
  1897.  {78.5714f,14.2857f},
  1898.  {83.3334f,28.5714f},
  1899.  {83.3334f,38.0952f},
  1900.  {78.5714f,52.381f},
  1901.  {69.0476f,61.9048f},
  1902.  {59.5238f,66.6667f},
  1903.  {45.2381f,66.6667f}
  1904. };
  1905. static const SFG_StrokeStrip ch111st[] =
  1906. {
  1907.  {17,ch111st0}
  1908. };
  1909. static const SFG_StrokeChar ch111 = {104.762f,1,ch111st};
  1910. /* char: 0x70 */
  1911. static const SFG_StrokeVertex ch112st0[] =
  1912. {
  1913.  {23.8095f,66.6667f},
  1914.  {23.8095f,-33.3333f}
  1915. };
  1916. static const SFG_StrokeVertex ch112st1[] =
  1917. {
  1918.  {23.8095f,52.381f},
  1919.  {33.3333f,61.9048f},
  1920.  {42.8571f,66.6667f},
  1921.  {57.1428f,66.6667f},
  1922.  {66.6666f,61.9048f},
  1923.  {76.1905f,52.381f},
  1924.  {80.9524f,38.0952f},
  1925.  {80.9524f,28.5714f},
  1926.  {76.1905f,14.2857f},
  1927.  {66.6666f,4.7619f},
  1928.  {57.1428f,0.0f},
  1929.  {42.8571f,0.0f},
  1930.  {33.3333f,4.7619f},
  1931.  {23.8095f,14.2857f}
  1932. };
  1933. static const SFG_StrokeStrip ch112st[] =
  1934. {
  1935.  {2,ch112st0},
  1936.  {14,ch112st1}
  1937. };
  1938. static const SFG_StrokeChar ch112 = {104.762f,2,ch112st};
  1939. /* char: 0x71 */
  1940. static const SFG_StrokeVertex ch113st0[] =
  1941. {
  1942.  {80.9524f,66.6667f},
  1943.  {80.9524f,-33.3333f}
  1944. };
  1945. static const SFG_StrokeVertex ch113st1[] =
  1946. {
  1947.  {80.9524f,52.381f},
  1948.  {71.4285f,61.9048f},
  1949.  {61.9047f,66.6667f},
  1950.  {47.619f,66.6667f},
  1951.  {38.0952f,61.9048f},
  1952.  {28.5714f,52.381f},
  1953.  {23.8095f,38.0952f},
  1954.  {23.8095f,28.5714f},
  1955.  {28.5714f,14.2857f},
  1956.  {38.0952f,4.7619f},
  1957.  {47.619f,0.0f},
  1958.  {61.9047f,0.0f},
  1959.  {71.4285f,4.7619f},
  1960.  {80.9524f,14.2857f}
  1961. };
  1962. static const SFG_StrokeStrip ch113st[] =
  1963. {
  1964.  {2,ch113st0},
  1965.  {14,ch113st1}
  1966. };
  1967. static const SFG_StrokeChar ch113 = {104.762f,2,ch113st};
  1968. /* char: 0x72 */
  1969. static const SFG_StrokeVertex ch114st0[] =
  1970. {
  1971.  {33.3334f,66.6667f},
  1972.  {33.3334f,0.0f}
  1973. };
  1974. static const SFG_StrokeVertex ch114st1[] =
  1975. {
  1976.  {33.3334f,38.0952f},
  1977.  {38.0953f,52.381f},
  1978.  {47.6191f,61.9048f},
  1979.  {57.1429f,66.6667f},
  1980.  {71.4286f,66.6667f}
  1981. };
  1982. static const SFG_StrokeStrip ch114st[] =
  1983. {
  1984.  {2,ch114st0},
  1985.  {5,ch114st1}
  1986. };
  1987. static const SFG_StrokeChar ch114 = {104.762f,2,ch114st};
  1988. /* char: 0x73 */
  1989. static const SFG_StrokeVertex ch115st0[] =
  1990. {
  1991.  {78.5715f,52.381f},
  1992.  {73.8095f,61.9048f},
  1993.  {59.5238f,66.6667f},
  1994.  {45.2381f,66.6667f},
  1995.  {30.9524f,61.9048f},
  1996.  {26.1905f,52.381f},
  1997.  {30.9524f,42.8571f},
  1998.  {40.4762f,38.0952f},
  1999.  {64.2857f,33.3333f},
  2000.  {73.8095f,28.5714f},
  2001.  {78.5715f,19.0476f},
  2002.  {78.5715f,14.2857f},
  2003.  {73.8095f,4.7619f},
  2004.  {59.5238f,0.0f},
  2005.  {45.2381f,0.0f},
  2006.  {30.9524f,4.7619f},
  2007.  {26.1905f,14.2857f}
  2008. };
  2009. static const SFG_StrokeStrip ch115st[] =
  2010. {
  2011.  {17,ch115st0}
  2012. };
  2013. static const SFG_StrokeChar ch115 = {104.762f,1,ch115st};
  2014. /* char: 0x74 */
  2015. static const SFG_StrokeVertex ch116st0[] =
  2016. {
  2017.  {47.6191f,100.0f},
  2018.  {47.6191f,19.0476f},
  2019.  {52.381f,4.7619f},
  2020.  {61.9048f,0.0f},
  2021.  {71.4286f,0.0f}
  2022. };
  2023. static const SFG_StrokeVertex ch116st1[] =
  2024. {
  2025.  {33.3334f,66.6667f},
  2026.  {66.6667f,66.6667f}
  2027. };
  2028. static const SFG_StrokeStrip ch116st[] =
  2029. {
  2030.  {5,ch116st0},
  2031.  {2,ch116st1}
  2032. };
  2033. static const SFG_StrokeChar ch116 = {104.762f,2,ch116st};
  2034. /* char: 0x75 */
  2035. static const SFG_StrokeVertex ch117st0[] =
  2036. {
  2037.  {26.1905f,66.6667f},
  2038.  {26.1905f,19.0476f},
  2039.  {30.9524f,4.7619f},
  2040.  {40.4762f,0.0f},
  2041.  {54.7619f,0.0f},
  2042.  {64.2857f,4.7619f},
  2043.  {78.5715f,19.0476f}
  2044. };
  2045. static const SFG_StrokeVertex ch117st1[] =
  2046. {
  2047.  {78.5715f,66.6667f},
  2048.  {78.5715f,0.0f}
  2049. };
  2050. static const SFG_StrokeStrip ch117st[] =
  2051. {
  2052.  {7,ch117st0},
  2053.  {2,ch117st1}
  2054. };
  2055. static const SFG_StrokeChar ch117 = {104.762f,2,ch117st};
  2056. /* char: 0x76 */
  2057. static const SFG_StrokeVertex ch118st0[] =
  2058. {
  2059.  {23.8095f,66.6667f},
  2060.  {52.3809f,0.0f}
  2061. };
  2062. static const SFG_StrokeVertex ch118st1[] =
  2063. {
  2064.  {80.9524f,66.6667f},
  2065.  {52.3809f,0.0f}
  2066. };
  2067. static const SFG_StrokeStrip ch118st[] =
  2068. {
  2069.  {2,ch118st0},
  2070.  {2,ch118st1}
  2071. };
  2072. static const SFG_StrokeChar ch118 = {104.762f,2,ch118st};
  2073. /* char: 0x77 */
  2074. static const SFG_StrokeVertex ch119st0[] =
  2075. {
  2076.  {14.2857f,66.6667f},
  2077.  {33.3333f,0.0f}
  2078. };
  2079. static const SFG_StrokeVertex ch119st1[] =
  2080. {
  2081.  {52.3809f,66.6667f},
  2082.  {33.3333f,0.0f}
  2083. };
  2084. static const SFG_StrokeVertex ch119st2[] =
  2085. {
  2086.  {52.3809f,66.6667f},
  2087.  {71.4286f,0.0f}
  2088. };
  2089. static const SFG_StrokeVertex ch119st3[] =
  2090. {
  2091.  {90.4762f,66.6667f},
  2092.  {71.4286f,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 = {104.762f,4,ch119st};
  2102. /* char: 0x78 */
  2103. static const SFG_StrokeVertex ch120st0[] =
  2104. {
  2105.  {26.1905f,66.6667f},
  2106.  {78.5715f,0.0f}
  2107. };
  2108. static const SFG_StrokeVertex ch120st1[] =
  2109. {
  2110.  {78.5715f,66.6667f},
  2111.  {26.1905f,0.0f}
  2112. };
  2113. static const SFG_StrokeStrip ch120st[] =
  2114. {
  2115.  {2,ch120st0},
  2116.  {2,ch120st1}
  2117. };
  2118. static const SFG_StrokeChar ch120 = {104.762f,2,ch120st};
  2119. /* char: 0x79 */
  2120. static const SFG_StrokeVertex ch121st0[] =
  2121. {
  2122.  {26.1905f,66.6667f},
  2123.  {54.7619f,0.0f}
  2124. };
  2125. static const SFG_StrokeVertex ch121st1[] =
  2126. {
  2127.  {83.3334f,66.6667f},
  2128.  {54.7619f,0.0f},
  2129.  {45.2381f,-19.0476f},
  2130.  {35.7143f,-28.5714f},
  2131.  {26.1905f,-33.3333f},
  2132.  {21.4286f,-33.3333f}
  2133. };
  2134. static const SFG_StrokeStrip ch121st[] =
  2135. {
  2136.  {2,ch121st0},
  2137.  {6,ch121st1}
  2138. };
  2139. static const SFG_StrokeChar ch121 = {104.762f,2,ch121st};
  2140. /* char: 0x7a */
  2141. static const SFG_StrokeVertex ch122st0[] =
  2142. {
  2143.  {78.5715f,66.6667f},
  2144.  {26.1905f,0.0f}
  2145. };
  2146. static const SFG_StrokeVertex ch122st1[] =
  2147. {
  2148.  {26.1905f,66.6667f},
  2149.  {78.5715f,66.6667f}
  2150. };
  2151. static const SFG_StrokeVertex ch122st2[] =
  2152. {
  2153.  {26.1905f,0.0f},
  2154.  {78.5715f,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 = {104.762f,3,ch122st};
  2163. /* char: 0x7b */
  2164. static const SFG_StrokeVertex ch123st0[] =
  2165. {
  2166.  {64.2857f,119.048f},
  2167.  {54.7619f,114.286f},
  2168.  {50.0f,109.524f},
  2169.  {45.2381f,100.0f},
  2170.  {45.2381f,90.4762f},
  2171.  {50.0f,80.9524f},
  2172.  {54.7619f,76.1905f},
  2173.  {59.5238f,66.6667f},
  2174.  {59.5238f,57.1429f},
  2175.  {50.0f,47.619f}
  2176. };
  2177. static const SFG_StrokeVertex ch123st1[] =
  2178. {
  2179.  {54.7619f,114.286f},
  2180.  {50.0f,104.762f},
  2181.  {50.0f,95.2381f},
  2182.  {54.7619f,85.7143f},
  2183.  {59.5238f,80.9524f},
  2184.  {64.2857f,71.4286f},
  2185.  {64.2857f,61.9048f},
  2186.  {59.5238f,52.381f},
  2187.  {40.4762f,42.8571f},
  2188.  {59.5238f,33.3333f},
  2189.  {64.2857f,23.8095f},
  2190.  {64.2857f,14.2857f},
  2191.  {59.5238f,4.7619f},
  2192.  {54.7619f,0.0f},
  2193.  {50.0f,-9.5238f},
  2194.  {50.0f,-19.0476f},
  2195.  {54.7619f,-28.5714f}
  2196. };
  2197. static const SFG_StrokeVertex ch123st2[] =
  2198. {
  2199.  {50.0f,38.0952f},
  2200.  {59.5238f,28.5714f},
  2201.  {59.5238f,19.0476f},
  2202.  {54.7619f,9.5238f},
  2203.  {50.0f,4.7619f},
  2204.  {45.2381f,-4.7619f},
  2205.  {45.2381f,-14.2857f},
  2206.  {50.0f,-23.8095f},
  2207.  {54.7619f,-28.5714f},
  2208.  {64.2857f,-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 = {104.762f,3,ch123st};
  2217. /* char: 0x7c */
  2218. static const SFG_StrokeVertex ch124st0[] =
  2219. {
  2220.  {52.381f,119.048f},
  2221.  {52.381f,-33.3333f}
  2222. };
  2223. static const SFG_StrokeStrip ch124st[] =
  2224. {
  2225.  {2,ch124st0}
  2226. };
  2227. static const SFG_StrokeChar ch124 = {104.762f,1,ch124st};
  2228. /* char: 0x7d */
  2229. static const SFG_StrokeVertex ch125st0[] =
  2230. {
  2231.  {40.4762f,119.048f},
  2232.  {50.0f,114.286f},
  2233.  {54.7619f,109.524f},
  2234.  {59.5238f,100.0f},
  2235.  {59.5238f,90.4762f},
  2236.  {54.7619f,80.9524f},
  2237.  {50.0f,76.1905f},
  2238.  {45.2381f,66.6667f},
  2239.  {45.2381f,57.1429f},
  2240.  {54.7619f,47.619f}
  2241. };
  2242. static const SFG_StrokeVertex ch125st1[] =
  2243. {
  2244.  {50.0f,114.286f},
  2245.  {54.7619f,104.762f},
  2246.  {54.7619f,95.2381f},
  2247.  {50.0f,85.7143f},
  2248.  {45.2381f,80.9524f},
  2249.  {40.4762f,71.4286f},
  2250.  {40.4762f,61.9048f},
  2251.  {45.2381f,52.381f},
  2252.  {64.2857f,42.8571f},
  2253.  {45.2381f,33.3333f},
  2254.  {40.4762f,23.8095f},
  2255.  {40.4762f,14.2857f},
  2256.  {45.2381f,4.7619f},
  2257.  {50.0f,0.0f},
  2258.  {54.7619f,-9.5238f},
  2259.  {54.7619f,-19.0476f},
  2260.  {50.0f,-28.5714f}
  2261. };
  2262. static const SFG_StrokeVertex ch125st2[] =
  2263. {
  2264.  {54.7619f,38.0952f},
  2265.  {45.2381f,28.5714f},
  2266.  {45.2381f,19.0476f},
  2267.  {50.0f,9.5238f},
  2268.  {54.7619f,4.7619f},
  2269.  {59.5238f,-4.7619f},
  2270.  {59.5238f,-14.2857f},
  2271.  {54.7619f,-23.8095f},
  2272.  {50.0f,-28.5714f},
  2273.  {40.4762f,-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 = {104.762f,3,ch125st};
  2282. /* char: 0x7e */
  2283. static const SFG_StrokeVertex ch126st0[] =
  2284. {
  2285.  {9.5238f,28.5714f},
  2286.  {9.5238f,38.0952f},
  2287.  {14.2857f,52.381f},
  2288.  {23.8095f,57.1429f},
  2289.  {33.3333f,57.1429f},
  2290.  {42.8571f,52.381f},
  2291.  {61.9048f,38.0952f},
  2292.  {71.4286f,33.3333f},
  2293.  {80.9524f,33.3333f},
  2294.  {90.4762f,38.0952f},
  2295.  {95.2381f,47.619f}
  2296. };
  2297. static const SFG_StrokeVertex ch126st1[] =
  2298. {
  2299.  {9.5238f,38.0952f},
  2300.  {14.2857f,47.619f},
  2301.  {23.8095f,52.381f},
  2302.  {33.3333f,52.381f},
  2303.  {42.8571f,47.619f},
  2304.  {61.9048f,33.3333f},
  2305.  {71.4286f,28.5714f},
  2306.  {80.9524f,28.5714f},
  2307.  {90.4762f,33.3333f},
  2308.  {95.2381f,47.619f},
  2309.  {95.2381f,57.1429f}
  2310. };
  2311. static const SFG_StrokeStrip ch126st[] =
  2312. {
  2313.  {11,ch126st0},
  2314.  {11,ch126st1}
  2315. };
  2316. static const SFG_StrokeChar ch126 = {104.762f,2,ch126st};
  2317. /* char: 0x7f */
  2318. static const SFG_StrokeVertex ch127st0[] =
  2319. {
  2320.  {71.4286f,100.0f},
  2321.  {33.3333f,-33.3333f}
  2322. };
  2323. static const SFG_StrokeVertex ch127st1[] =
  2324. {
  2325.  {47.619f,66.6667f},
  2326.  {33.3333f,61.9048f},
  2327.  {23.8095f,52.381f},
  2328.  {19.0476f,38.0952f},
  2329.  {19.0476f,23.8095f},
  2330.  {23.8095f,14.2857f},
  2331.  {33.3333f,4.7619f},
  2332.  {47.619f,0.0f},
  2333.  {57.1428f,0.0f},
  2334.  {71.4286f,4.7619f},
  2335.  {80.9524f,14.2857f},
  2336.  {85.7143f,28.5714f},
  2337.  {85.7143f,42.8571f},
  2338.  {80.9524f,52.381f},
  2339.  {71.4286f,61.9048f},
  2340.  {57.1428f,66.6667f},
  2341.  {47.619f,66.6667f}
  2342. };
  2343. static const SFG_StrokeStrip ch127st[] =
  2344. {
  2345.  {2,ch127st0},
  2346.  {17,ch127st1}
  2347. };
  2348. static const SFG_StrokeChar ch127 = {104.762f,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 fgStrokeMonoRoman = {"MonoRoman",128,152.381f,chars};