← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/box2d/freeglut/freeglut_stroke_roman.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

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