1 /* ctx git commit: beb18017 */ 2 /* 3 * ctx.h is free software; you can redistribute it and/or 4 * modify it under the terms of the GNU Lesser General Public 5 * License as published by the Free Software Foundation; either 6 * version 3 of the License, or (at your option) any later version. 7 * 8 * ctx.h is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * Lesser General Public License for more details. 12 * 13 * You should have received a copy of the GNU Lesser General Public 14 * License along with ctx; if not, see <https://www.gnu.org/licenses/>. 15 * 16 * 2012, 2015, 2019, 2020 Øyvind Kolås <pippin@gimp.org> 17 * 18 * ctx is a single header 2d vector graphics processing framework. 19 * 20 * To use ctx in a project, do the following: 21 * 22 * #define CTX_IMPLEMENTATION 23 * #include "ctx.h" 24 * 25 * Ctx contains a minimal default fallback font with only ascii, so 26 * you probably want to also include a font, and perhaps enable 27 * the cairo or SDL2 optional renderers, a more complete example 28 * could be: 29 * 30 * #include <cairo.h> 31 * #include <SDL.h> 32 * #include "ctx-font-regular.h" 33 * #define CTX_IMPLEMENTATION 34 * #include "ctx.h" 35 * 36 * The behavior of ctx can be tweaked, and features can be configured, 37 enabled 38 * or disabled with other #defines, see further down in the start of this 39 file 40 * for details. 41 */ 42 43 #ifndef CTX_H 44 #define CTX_H 45 46 #ifdef __cplusplus 47 extern "C" { 48 #endif 49 50 #if !__COSMOPOLITAN__ 51 #include <stdint.h> 52 #include <string.h> 53 #include <stdio.h> 54 #include <sys/select.h> // XXX if events? 55 #endif 56 57 typedef struct _Ctx Ctx; 58 59 /* The pixel formats supported as render targets 60 */ 61 enum _CtxPixelFormat 62 { 63 CTX_FORMAT_NONE=0, 64 CTX_FORMAT_GRAY8, // 1 - these enum values are not coincidence 65 CTX_FORMAT_GRAYA8, // 2 - 66 CTX_FORMAT_RGB8, // 3 - 67 CTX_FORMAT_RGBA8, // 4 - 68 CTX_FORMAT_BGRA8, // 5 69 CTX_FORMAT_RGB565, // 6 70 CTX_FORMAT_RGB565_BYTESWAPPED, // 7 71 CTX_FORMAT_RGB332, // 8 72 CTX_FORMAT_RGBAF, // 9 73 CTX_FORMAT_GRAYF, // 10 74 CTX_FORMAT_GRAYAF, // 11 75 CTX_FORMAT_GRAY1, //12 MONO 76 CTX_FORMAT_GRAY2, //13 DUO 77 CTX_FORMAT_GRAY4, //14 78 CTX_FORMAT_CMYK8, //15 79 CTX_FORMAT_CMYKA8, //16 80 CTX_FORMAT_CMYKAF, //17 81 CTX_FORMAT_YUV420, //18 82 CTX_FORMAT_RGBA8_SEPARATE_ALPHA, // 19 83 }; 84 typedef enum _CtxPixelFormat CtxPixelFormat; 85 86 typedef struct _CtxGlyph CtxGlyph; 87 88 /** 89 * ctx_new: 90 * 91 * Create a new drawing context, this context has no pixels but 92 * accumulates commands and can be played back on other ctx 93 * render contexts. 94 */ 95 Ctx *ctx_new (void); 96 97 /** 98 * ctx_new_for_framebuffer: 99 * 100 * Create a new drawing context for a framebuffer, rendering happens 101 * immediately. 102 */ 103 Ctx *ctx_new_for_framebuffer (void *data, 104 int width, 105 int height, 106 int stride, 107 CtxPixelFormat pixel_format); 108 /** 109 * ctx_new_ui: 110 * 111 * Create a new interactive ctx context, might depend on additional 112 * integration. 113 */ 114 Ctx *ctx_new_ui (int width, int height); 115 116 /** 117 * ctx_new_for_drawlist: 118 * 119 * Create a new drawing context for a pre-existing drawlist. 120 */ 121 Ctx *ctx_new_for_drawlist (void *data, size_t length); 122 123 124 /** 125 * ctx_dirty_rect: 126 * 127 * Query the dirtied bounding box of drawing commands thus far. 128 */ 129 void ctx_dirty_rect (Ctx *ctx, int *x, int *y, int *width, int 130 *height); 131 132 /** 133 * ctx_free: 134 * @ctx: a ctx context 135 */ 136 void ctx_free (Ctx *ctx); 137 138 /* clears and resets a context */ 139 void ctx_reset (Ctx *ctx); 140 void ctx_begin_path (Ctx *ctx); 141 void ctx_save (Ctx *ctx); 142 void ctx_restore (Ctx *ctx); 143 void ctx_start_group (Ctx *ctx); 144 void ctx_end_group (Ctx *ctx); 145 void ctx_clip (Ctx *ctx); 146 void ctx_identity (Ctx *ctx); 147 void ctx_rotate (Ctx *ctx, float x); 148 149 void ctx_image_smoothing (Ctx *ctx, int enabled); 150 int ctx_get_image_smoothing (Ctx *ctx); 151 152 #define CTX_LINE_WIDTH_HAIRLINE -1000.0 153 #define CTX_LINE_WIDTH_ALIASED -1.0 154 #define CTX_LINE_WIDTH_FAST -1.0 /* aliased 1px wide line */ 155 void ctx_miter_limit (Ctx *ctx, float limit); 156 float ctx_get_miter_limit (Ctx *ctx); 157 void ctx_line_width (Ctx *ctx, float x); 158 void ctx_line_dash_offset (Ctx *ctx, float line_dash); 159 float ctx_get_line_dash_offset (Ctx *ctx); 160 void ctx_apply_transform (Ctx *ctx, float a, float b, // hscale, hskew 161 float c, float d, // vskew, vscale 162 float e, float f); // htran, vtran 163 void ctx_set_transform (Ctx *ctx, float a, float b, float c, float d, 164 float e, float f); 165 void ctx_line_dash (Ctx *ctx, float *dashes, int count); 166 void ctx_font_size (Ctx *ctx, float x); 167 void ctx_font (Ctx *ctx, const char *font); 168 void ctx_font_family (Ctx *ctx, const char *font_family); 169 void ctx_scale (Ctx *ctx, float x, float y); 170 void ctx_translate (Ctx *ctx, float x, float y); 171 void ctx_line_to (Ctx *ctx, float x, float y); 172 void ctx_move_to (Ctx *ctx, float x, float y); 173 void ctx_curve_to (Ctx *ctx, float cx0, float cy0, 174 float cx1, float cy1, 175 float x, float y); 176 void ctx_quad_to (Ctx *ctx, float cx, float cy, 177 float x, float y); 178 void ctx_arc (Ctx *ctx, 179 float x, float y, 180 float radius, 181 float angle1, float angle2, 182 int direction); 183 void ctx_arc_to (Ctx *ctx, float x1, float y1, 184 float x2, float y2, float radius); 185 void ctx_rel_arc_to (Ctx *ctx, float x1, float y1, 186 float x2, float y2, float radius); 187 void ctx_rectangle (Ctx *ctx, 188 float x0, float y0, 189 float w, float h); 190 void ctx_round_rectangle (Ctx *ctx, 191 float x0, float y0, 192 float w, float h, 193 float radius); 194 void ctx_rel_line_to (Ctx *ctx, 195 float x, float y); 196 void ctx_rel_move_to (Ctx *ctx, 197 float x, float y); 198 void ctx_rel_curve_to (Ctx *ctx, 199 float x0, float y0, 200 float x1, float y1, 201 float x2, float y2); 202 void ctx_rel_quad_to (Ctx *ctx, 203 float cx, float cy, 204 float x, float y); 205 void ctx_close_path (Ctx *ctx); 206 float ctx_get_font_size (Ctx *ctx); 207 const char *ctx_get_font (Ctx *ctx); 208 float ctx_get_line_width (Ctx *ctx); 209 int ctx_width (Ctx *ctx); 210 int ctx_height (Ctx *ctx); 211 int ctx_rev (Ctx *ctx); 212 float ctx_x (Ctx *ctx); 213 float ctx_y (Ctx *ctx); 214 void ctx_current_point (Ctx *ctx, float *x, float *y); 215 void ctx_get_transform (Ctx *ctx, float *a, float *b, 216 float *c, float *d, 217 float *e, float *f); 218 219 CtxGlyph *ctx_glyph_allocate (int n_glyphs); 220 221 void gtx_glyph_free (CtxGlyph *glyphs); 222 223 int ctx_glyph (Ctx *ctx, uint32_t unichar, int stroke); 224 225 void ctx_preserve (Ctx *ctx); 226 void ctx_fill (Ctx *ctx); 227 void ctx_stroke (Ctx *ctx); 228 229 void ctx_parse (Ctx *ctx, const char *string); 230 231 void ctx_shadow_rgba (Ctx *ctx, float r, float g, float b, float a); 232 void ctx_shadow_blur (Ctx *ctx, float x); 233 void ctx_shadow_offset_x (Ctx *ctx, float x); 234 void ctx_shadow_offset_y (Ctx *ctx, float y); 235 void ctx_view_box (Ctx *ctx, 236 float x0, float y0, 237 float w, float h); 238 void 239 ctx_set_pixel_u8 (Ctx *ctx, uint16_t x, uint16_t y, uint8_t r, 240 uint8_t g, uint8_t b, uint8_t a); 241 242 void ctx_global_alpha (Ctx *ctx, float global_alpha); 243 float ctx_get_global_alpha (Ctx *ctx); 244 245 void ctx_named_source (Ctx *ctx, const char *name); 246 // followed by a color, gradient or pattern definition 247 248 void ctx_stroke_source (Ctx *ctx); // next source definition is for 249 stroking 250 251 void ctx_rgba_stroke (Ctx *ctx, float r, float g, float b, float a); 252 void ctx_rgb_stroke (Ctx *ctx, float r, float g, float b); 253 void ctx_rgba8_stroke (Ctx *ctx, uint8_t r, uint8_t g, uint8_t b, uint8_t 254 a); 255 256 void ctx_gray_stroke (Ctx *ctx, float gray); 257 void ctx_drgba_stroke (Ctx *ctx, float r, float g, float b, float a); 258 void ctx_cmyka_stroke (Ctx *ctx, float c, float m, float y, float k, float 259 a); 260 void ctx_cmyk_stroke (Ctx *ctx, float c, float m, float y, float k); 261 void ctx_dcmyka_stroke (Ctx *ctx, float c, float m, float y, float k, float 262 a); 263 void ctx_dcmyk_stroke (Ctx *ctx, float c, float m, float y, float k); 264 265 266 267 void ctx_rgba (Ctx *ctx, float r, float g, float b, float a); 268 void ctx_rgb (Ctx *ctx, float r, float g, float b); 269 void ctx_rgba8 (Ctx *ctx, uint8_t r, uint8_t g, uint8_t b, uint8_t a); 270 271 void ctx_gray (Ctx *ctx, float gray); 272 void ctx_drgba (Ctx *ctx, float r, float g, float b, float a); 273 void ctx_cmyka (Ctx *ctx, float c, float m, float y, float k, float a); 274 void ctx_cmyk (Ctx *ctx, float c, float m, float y, float k); 275 void ctx_dcmyka (Ctx *ctx, float c, float m, float y, float k, float a); 276 void ctx_dcmyk (Ctx *ctx, float c, float m, float y, float k); 277 278 /* there is also getters for colors, by first setting a color in one format 279 and getting 280 * it with another color conversions can be done 281 */ 282 283 void ctx_get_rgba (Ctx *ctx, float *rgba); 284 void ctx_get_graya (Ctx *ctx, float *ya); 285 void ctx_get_drgba (Ctx *ctx, float *drgba); 286 void ctx_get_cmyka (Ctx *ctx, float *cmyka); 287 void ctx_get_dcmyka (Ctx *ctx, float *dcmyka); 288 int ctx_in_fill (Ctx *ctx, float x, float y); 289 int ctx_in_stroke (Ctx *ctx, float x, float y); 290 291 void ctx_linear_gradient (Ctx *ctx, float x0, float y0, float x1, float y1); 292 void ctx_radial_gradient (Ctx *ctx, float x0, float y0, float r0, 293 float x1, float y1, float r1); 294 /* XXX should be ctx_gradient_add_stop_rgba */ 295 void ctx_gradient_add_stop (Ctx *ctx, float pos, float r, float g, float b, 296 float a); 297 298 void ctx_gradient_add_stop_u8 (Ctx *ctx, float pos, uint8_t r, uint8_t g, 299 uint8_t b, uint8_t a); 300 301 302 /* 303 * 304 */ 305 void ctx_define_texture (Ctx *ctx, 306 const char *eid, 307 int width, 308 int height, 309 int stride, 310 int format, 311 void *data, 312 char *ret_eid); 313 314 void 315 ctx_source_transform (Ctx *ctx, float a, float b, // hscale, hskew 316 float c, float d, // vskew, vscale 317 float e, float f); // htran, vtran 318 typedef struct _CtxMatrix CtxMatrix; 319 void 320 ctx_source_transform_matrix (Ctx *ctx, CtxMatrix *matrix); 321 322 void 323 ctx_get_image_data (Ctx *ctx, int sx, int sy, int sw, int sh, 324 CtxPixelFormat format, int dst_stride, 325 uint8_t *dst_data); 326 327 void 328 ctx_put_image_data (Ctx *ctx, int w, int h, int stride, int format, 329 uint8_t *data, 330 int ox, int oy, 331 int dirtyX, int dirtyY, 332 int dirtyWidth, int dirtyHeight); 333 334 335 /* loads an image file from disk into texture, returning pixel width, 336 height 337 * and eid, the eid is based on the path; not the contents - avoiding doing 338 * sha1 checksum of contents. The width and height of the image is returned 339 * along with the used eid, width height or eid can be NULL if we 340 * do not care about their values. 341 */ 342 void ctx_texture_load (Ctx *ctx, 343 const char *path, 344 int *width, 345 int *height, 346 char *eid); 347 348 /* sets the paint source to be a texture by eid 349 */ 350 void ctx_texture (Ctx *ctx, const char *eid, float x, float y); 351 352 void ctx_draw_texture (Ctx *ctx, const char *eid, float x, float y, 353 float w, float h); 354 355 void ctx_draw_texture_clipped (Ctx *ctx, const char *eid, float x, float y, 356 float w, float h, float sx, float sy, float 357 swidth, float sheight); 358 359 void ctx_draw_image (Ctx *ctx, const char *path, float x, float y, 360 float w, float h); 361 362 void ctx_draw_image_clipped (Ctx *ctx, const char *path, float x, float y, 363 float w, float h, float sx, float sy, float 364 swidth, float sheight); 365 366 /* used by the render threads of fb and sdl backends. 367 */ 368 void ctx_set_texture_source (Ctx *ctx, Ctx *texture_source); 369 /* used when sharing cache state of eids between clients 370 */ 371 void ctx_set_texture_cache (Ctx *ctx, Ctx *texture_cache); 372 373 typedef struct _CtxDrawlist CtxDrawlist; 374 typedef void (*CtxFullCb) (CtxDrawlist *drawlist, void *data); 375 376 int ctx_pixel_format_bits_per_pixel (CtxPixelFormat format); // bits per 377 pixel 378 int ctx_pixel_format_get_stride (CtxPixelFormat format, int width); 379 int ctx_pixel_format_components (CtxPixelFormat format); 380 381 void _ctx_set_store_clear (Ctx *ctx); 382 void _ctx_set_transformation (Ctx *ctx, int transformation); 383 384 Ctx *ctx_hasher_new (int width, int height, int cols, int rows); 385 uint8_t *ctx_hasher_get_hash (Ctx *ctx, int col, int row); 386 387 int ctx_utf8_strlen (const char *s); 388 389 #ifdef _BABL_H 390 #define CTX_BABL 1 391 #else 392 #define CTX_BABL 0 393 #endif 394 395 /* If cairo.h is included before ctx.h add cairo integration code 396 */ 397 #ifdef CAIRO_H 398 #define CTX_CAIRO 1 399 #else 400 #define CTX_CAIRO 0 401 #endif 402 403 #ifndef CTX_SDL 404 #ifdef SDL_h_ 405 #define CTX_SDL 1 406 #else 407 #define CTX_SDL 0 408 #endif 409 #endif 410 411 #ifndef CTX_FB 412 #define CTX_FB 0 413 #endif 414 415 #ifndef CTX_DRM 416 #define CTX_DRM 0 417 #endif 418 419 #if CTX_SDL 420 #define ctx_mutex_t SDL_mutex 421 #define ctx_create_mutex() SDL_CreateMutex() 422 #define ctx_lock_mutex(a) SDL_LockMutex(a) 423 #define ctx_unlock_mutex(a) SDL_UnlockMutex(a) 424 #else 425 #define ctx_mutex_t int 426 #define ctx_create_mutex() NULL 427 #define ctx_lock_mutex(a) 428 #define ctx_unlock_mutex(a) 429 #endif 430 431 #if CTX_CAIRO 432 433 /* render the deferred commands of a ctx context to a cairo 434 * context 435 */ 436 void ctx_render_cairo (Ctx *ctx, cairo_t *cr); 437 438 /* create a ctx context that directly renders to the specified 439 * cairo context 440 */ 441 Ctx * ctx_new_for_cairo (cairo_t *cr); 442 #endif 443 444 /* free with free() */ 445 char *ctx_render_string (Ctx *ctx, int longform, int *retlen); 446 447 void ctx_render_stream (Ctx *ctx, FILE *stream, int formatter); 448 449 void ctx_render_ctx (Ctx *ctx, Ctx *d_ctx); 450 void ctx_render_ctx_textures (Ctx *ctx, Ctx *d_ctx); /* cycles through all 451 used texture eids 452 */ 453 454 void ctx_start_move (Ctx *ctx); 455 456 457 int ctx_add_single (Ctx *ctx, void *entry); 458 459 uint32_t ctx_utf8_to_unichar (const char *input); 460 int ctx_unichar_to_utf8 (uint32_t ch, uint8_t *dest); 461 462 463 typedef enum 464 { 465 CTX_FILL_RULE_WINDING, 466 CTX_FILL_RULE_EVEN_ODD 467 } CtxFillRule; 468 469 typedef enum 470 { 471 #if 0 472 CTX_COMPOSITE_SOURCE_OVER = 0, 473 CTX_COMPOSITE_COPY = 32, 474 CTX_COMPOSITE_SOURCE_IN = 64, 475 CTX_COMPOSITE_SOURCE_OUT = 96, 476 CTX_COMPOSITE_SOURCE_ATOP = 128, 477 CTX_COMPOSITE_CLEAR = 160, 478 479 CTX_COMPOSITE_DESTINATION_OVER = 192, 480 CTX_COMPOSITE_DESTINATION = 224, 481 CTX_COMPOSITE_DESTINATION_IN = 256, 482 CTX_COMPOSITE_DESTINATION_OUT = 288, 483 CTX_COMPOSITE_DESTINATION_ATOP = 320, 484 CTX_COMPOSITE_XOR = 352, 485 486 CTX_COMPOSITE_ALL = (32+64+128+256) 487 #else 488 CTX_COMPOSITE_SOURCE_OVER =0, 489 CTX_COMPOSITE_COPY , 490 CTX_COMPOSITE_SOURCE_IN , 491 CTX_COMPOSITE_SOURCE_OUT , 492 CTX_COMPOSITE_SOURCE_ATOP , 493 CTX_COMPOSITE_CLEAR , 494 495 CTX_COMPOSITE_DESTINATION_OVER , 496 CTX_COMPOSITE_DESTINATION , 497 CTX_COMPOSITE_DESTINATION_IN , 498 CTX_COMPOSITE_DESTINATION_OUT , 499 CTX_COMPOSITE_DESTINATION_ATOP , 500 CTX_COMPOSITE_XOR , 501 #endif 502 } CtxCompositingMode; 503 504 typedef enum 505 { 506 CTX_BLEND_NORMAL, 507 CTX_BLEND_MULTIPLY, 508 CTX_BLEND_SCREEN, 509 CTX_BLEND_OVERLAY, 510 CTX_BLEND_DARKEN, 511 CTX_BLEND_LIGHTEN, 512 CTX_BLEND_COLOR_DODGE, 513 CTX_BLEND_COLOR_BURN, 514 CTX_BLEND_HARD_LIGHT, 515 CTX_BLEND_SOFT_LIGHT, 516 CTX_BLEND_DIFFERENCE, 517 CTX_BLEND_EXCLUSION, 518 CTX_BLEND_HUE, 519 CTX_BLEND_SATURATION, 520 CTX_BLEND_COLOR, 521 CTX_BLEND_LUMINOSITY, // 15 522 CTX_BLEND_DIVIDE, 523 CTX_BLEND_ADDITION, 524 CTX_BLEND_SUBTRACT, // 18 525 } CtxBlend; 526 527 void ctx_blend_mode (Ctx *ctx, CtxBlend mode); 528 529 typedef enum 530 { 531 CTX_JOIN_BEVEL = 0, 532 CTX_JOIN_ROUND = 1, 533 CTX_JOIN_MITER = 2 534 } CtxLineJoin; 535 536 typedef enum 537 { 538 CTX_CAP_NONE = 0, 539 CTX_CAP_ROUND = 1, 540 CTX_CAP_SQUARE = 2 541 } CtxLineCap; 542 543 typedef enum 544 { 545 CTX_TEXT_BASELINE_ALPHABETIC = 0, 546 CTX_TEXT_BASELINE_TOP, 547 CTX_TEXT_BASELINE_HANGING, 548 CTX_TEXT_BASELINE_MIDDLE, 549 CTX_TEXT_BASELINE_IDEOGRAPHIC, 550 CTX_TEXT_BASELINE_BOTTOM 551 } CtxTextBaseline; 552 553 typedef enum 554 { 555 CTX_TEXT_ALIGN_START = 0, 556 CTX_TEXT_ALIGN_END, 557 CTX_TEXT_ALIGN_CENTER, 558 CTX_TEXT_ALIGN_LEFT, 559 CTX_TEXT_ALIGN_RIGHT 560 } CtxTextAlign; 561 562 typedef enum 563 { 564 CTX_TEXT_DIRECTION_INHERIT = 0, 565 CTX_TEXT_DIRECTION_LTR, 566 CTX_TEXT_DIRECTION_RTL 567 } CtxTextDirection; 568 569 struct 570 _CtxGlyph 571 { 572 uint32_t index; 573 float x; 574 float y; 575 }; 576 577 CtxTextAlign ctx_get_text_align (Ctx *ctx); 578 CtxTextBaseline ctx_get_text_baseline (Ctx *ctx); 579 CtxTextDirection ctx_get_text_direction (Ctx *ctx); 580 CtxFillRule ctx_get_fill_rule (Ctx *ctx); 581 CtxLineCap ctx_get_line_cap (Ctx *ctx); 582 CtxLineJoin ctx_get_line_join (Ctx *ctx); 583 CtxCompositingMode ctx_get_compositing_mode (Ctx *ctx); 584 CtxBlend ctx_get_blend_mode (Ctx *ctx); 585 586 void ctx_gradient_add_stop_string (Ctx *ctx, float pos, const char *color); 587 588 void ctx_text_align (Ctx *ctx, CtxTextAlign align); 589 void ctx_text_baseline (Ctx *ctx, CtxTextBaseline baseline); 590 void ctx_text_direction (Ctx *ctx, CtxTextDirection direction); 591 void ctx_fill_rule (Ctx *ctx, CtxFillRule fill_rule); 592 void ctx_line_cap (Ctx *ctx, CtxLineCap cap); 593 void ctx_line_join (Ctx *ctx, CtxLineJoin join); 594 void ctx_compositing_mode (Ctx *ctx, CtxCompositingMode mode); 595 int ctx_set_drawlist (Ctx *ctx, void *data, int length); 596 typedef struct _CtxEntry CtxEntry; 597 /* we only care about the tight packing for this specific 598 * struct as we do indexing across members in arrays of it, 599 * to make sure its size becomes 9bytes - 600 * the pack pragma is also sufficient on recent gcc versions 601 */ 602 #pragma pack(push,1) 603 struct 604 _CtxEntry 605 { 606 uint8_t code; 607 union 608 { 609 float f[2]; 610 uint8_t u8[8]; 611 int8_t s8[8]; 612 uint16_t u16[4]; 613 int16_t s16[4]; 614 uint32_t u32[2]; 615 int32_t s32[2]; 616 uint64_t u64[1]; // unused 617 } data; // 9bytes long, we're favoring compactness and correctness 618 // over performance. By sacrificing float precision, zeroing 619 // first 8bit of f[0] would permit 8bytes long and better 620 // aglinment and cacheline behavior. 621 }; 622 #pragma pack(pop) 623 const CtxEntry *ctx_get_drawlist (Ctx *ctx); 624 int ctx_append_drawlist (Ctx *ctx, void *data, int length); 625 626 /* these are only needed for clients rendering text, as all text gets 627 * converted to paths. 628 */ 629 void ctx_glyphs (Ctx *ctx, 630 CtxGlyph *glyphs, 631 int n_glyphs); 632 633 void ctx_glyphs_stroke (Ctx *ctx, 634 CtxGlyph *glyphs, 635 int n_glyphs); 636 637 void ctx_text (Ctx *ctx, 638 const char *string); 639 void ctx_text_stroke (Ctx *ctx, 640 const char *string); 641 642 void ctx_fill_text (Ctx *ctx, 643 const char *string, 644 float x, 645 float y); 646 647 void ctx_stroke_text (Ctx *ctx, 648 const char *string, 649 float x, 650 float y); 651 652 /* returns the total horizontal advance if string had been rendered */ 653 float ctx_text_width (Ctx *ctx, 654 const char *string); 655 656 float ctx_glyph_width (Ctx *ctx, int unichar); 657 658 int ctx_load_font_ttf (const char *name, const void *ttf_contents, int 659 length); 660 661 662 663 enum _CtxModifierState 664 { 665 CTX_MODIFIER_STATE_SHIFT = (1<<0), 666 CTX_MODIFIER_STATE_CONTROL = (1<<1), 667 CTX_MODIFIER_STATE_ALT = (1<<2), 668 CTX_MODIFIER_STATE_BUTTON1 = (1<<3), 669 CTX_MODIFIER_STATE_BUTTON2 = (1<<4), 670 CTX_MODIFIER_STATE_BUTTON3 = (1<<5), 671 CTX_MODIFIER_STATE_DRAG = (1<<6), // pointer button is down (0 or any) 672 }; 673 typedef enum _CtxModifierState CtxModifierState; 674 675 enum _CtxScrollDirection 676 { 677 CTX_SCROLL_DIRECTION_UP, 678 CTX_SCROLL_DIRECTION_DOWN, 679 CTX_SCROLL_DIRECTION_LEFT, 680 CTX_SCROLL_DIRECTION_RIGHT 681 }; 682 typedef enum _CtxScrollDirection CtxScrollDirection; 683 684 typedef struct _CtxEvent CtxEvent; 685 686 void ctx_set_renderer (Ctx *ctx, 687 void *renderer); 688 void *ctx_get_renderer (Ctx *ctx); 689 690 int ctx_renderer_is_sdl (Ctx *ctx); 691 int ctx_renderer_is_fb (Ctx *ctx); 692 int ctx_renderer_is_drm (Ctx *ctx); 693 int ctx_renderer_is_tiled (Ctx *ctx); 694 int ctx_renderer_is_ctx (Ctx *ctx); 695 int ctx_renderer_is_term (Ctx *ctx); 696 697 /* the following API is only available when CTX_EVENTS is defined to 1 698 * 699 * it provides the ability to register callbacks with the current path 700 * that get delivered with transformed coordinates. 701 */ 702 int ctx_is_dirty (Ctx *ctx); 703 void ctx_set_dirty (Ctx *ctx, int dirty); 704 float ctx_get_float (Ctx *ctx, uint64_t hash); 705 void ctx_set_float (Ctx *ctx, uint64_t hash, float value); 706 707 unsigned long ctx_ticks (void); 708 void ctx_flush (Ctx *ctx); 709 710 void ctx_set_clipboard (Ctx *ctx, const char *text); 711 char *ctx_get_clipboard (Ctx *ctx); 712 713 void _ctx_events_init (Ctx *ctx); 714 typedef struct _CtxIntRectangle CtxIntRectangle; 715 struct _CtxIntRectangle { 716 int x; 717 int y; 718 int width; 719 int height; 720 }; 721 722 void ctx_quit (Ctx *ctx); 723 int ctx_has_quit (Ctx *ctx); 724 725 typedef void (*CtxCb) (CtxEvent *event, 726 void *data, 727 void *data2); 728 typedef void (*CtxDestroyNotify) (void *data); 729 730 enum _CtxEventType { 731 CTX_PRESS = 1 << 0, 732 CTX_MOTION = 1 << 1, 733 CTX_RELEASE = 1 << 2, 734 CTX_ENTER = 1 << 3, 735 CTX_LEAVE = 1 << 4, 736 CTX_TAP = 1 << 5, 737 CTX_TAP_AND_HOLD = 1 << 6, 738 739 /* NYI: SWIPE, ZOOM ROT_ZOOM, */ 740 741 CTX_DRAG_PRESS = 1 << 7, 742 CTX_DRAG_MOTION = 1 << 8, 743 CTX_DRAG_RELEASE = 1 << 9, 744 CTX_KEY_PRESS = 1 << 10, 745 CTX_KEY_DOWN = 1 << 11, 746 CTX_KEY_UP = 1 << 12, 747 CTX_SCROLL = 1 << 13, 748 CTX_MESSAGE = 1 << 14, 749 CTX_DROP = 1 << 15, 750 751 CTX_SET_CURSOR = 1 << 16, // used internally 752 753 /* client should store state - preparing 754 * for restart 755 */ 756 CTX_POINTER = (CTX_PRESS | CTX_MOTION | CTX_RELEASE | CTX_DROP), 757 CTX_TAPS = (CTX_TAP | CTX_TAP_AND_HOLD), 758 CTX_CROSSING = (CTX_ENTER | CTX_LEAVE), 759 CTX_DRAG = (CTX_DRAG_PRESS | CTX_DRAG_MOTION | CTX_DRAG_RELEASE), 760 CTX_KEY = (CTX_KEY_DOWN | CTX_KEY_UP | CTX_KEY_PRESS), 761 CTX_MISC = (CTX_MESSAGE), 762 CTX_ANY = (CTX_POINTER | CTX_DRAG | CTX_CROSSING | CTX_KEY | 763 CTX_MISC | CTX_TAPS), 764 }; 765 typedef enum _CtxEventType CtxEventType; 766 767 #define CTX_CLICK CTX_PRESS // SHOULD HAVE MORE LOGIC 768 769 struct _CtxEvent { 770 CtxEventType type; 771 uint32_t time; 772 Ctx *ctx; 773 int stop_propagate; /* when set - propagation is stopped */ 774 775 CtxModifierState state; 776 777 int device_no; /* 0 = left mouse button / virtual focus */ 778 /* 1 = middle mouse button */ 779 /* 2 = right mouse button */ 780 /* 3 = first multi-touch .. (NYI) */ 781 782 float device_x; /* untransformed (device) coordinates */ 783 float device_y; 784 785 /* coordinates; and deltas for motion/drag events in user-coordinates: */ 786 float x; 787 float y; 788 float start_x; /* start-coordinates (press) event for drag, */ 789 float start_y; /* untransformed coordinates */ 790 float prev_x; /* previous events coordinates */ 791 float prev_y; 792 float delta_x; /* x - prev_x, redundant - but often useful */ 793 float delta_y; /* y - prev_y, redundant - .. */ 794 795 796 unsigned int unicode; /* only valid for key-events, re-use as keycode? */ 797 const char *string; /* as key can be "up" "down" "space" "backspace" 798 "a" "b" "ø" etc .. */ 799 /* this is also where the message is delivered for 800 * MESSAGE events 801 * 802 * and the data for drop events are delivered 803 */ 804 CtxScrollDirection scroll_direction; 805 806 807 // would be nice to add the bounding box of the hit-area causing 808 // the event, making for instance scissored enter/leave repaint easier. 809 }; 810 811 // layer-event "layer" motion x y device_no 812 813 void ctx_add_key_binding_full (Ctx *ctx, 814 const char *key, 815 const char *action, 816 const char *label, 817 CtxCb cb, 818 void *cb_data, 819 CtxDestroyNotify destroy_notify, 820 void *destroy_data); 821 void ctx_add_key_binding (Ctx *ctx, 822 const char *key, 823 const char *action, 824 const char *label, 825 CtxCb cb, 826 void *cb_data); 827 typedef struct CtxBinding { 828 char *nick; 829 char *command; 830 char *label; 831 CtxCb cb; 832 void *cb_data; 833 CtxDestroyNotify destroy_notify; 834 void *destroy_data; 835 } CtxBinding; 836 CtxBinding *ctx_get_bindings (Ctx *ctx); 837 void ctx_clear_bindings (Ctx *ctx); 838 void ctx_remove_idle (Ctx *ctx, int handle); 839 int ctx_add_timeout_full (Ctx *ctx, int ms, int (*idle_cb)(Ctx *ctx, 840 void *idle_data), void *idle_data, 841 void (*destroy_notify)(void *destroy_data), 842 void *destroy_data); 843 int ctx_add_timeout (Ctx *ctx, int ms, int (*idle_cb)(Ctx *ctx, 844 void *idle_data), void *idle_data); 845 int ctx_add_idle_full (Ctx *ctx, int (*idle_cb)(Ctx *ctx, void 846 *idle_data), void *idle_data, 847 void (*destroy_notify)(void *destroy_data), 848 void *destroy_data); 849 int ctx_add_idle (Ctx *ctx, int (*idle_cb)(Ctx *ctx, void 850 *idle_data), void *idle_data); 851 852 853 void ctx_add_hit_region (Ctx *ctx, const char *id); 854 855 void ctx_set_title (Ctx *ctx, const char *title); 856 857 void ctx_listen_full (Ctx *ctx, 858 float x, 859 float y, 860 float width, 861 float height, 862 CtxEventType types, 863 CtxCb cb, 864 void *data1, 865 void *data2, 866 void (*finalize)(void *listen_data, void 867 *listen_data2, 868 void *finalize_data), 869 void *finalize_data); 870 void ctx_event_stop_propagate (CtxEvent *event); 871 void ctx_listen (Ctx *ctx, 872 CtxEventType types, 873 CtxCb cb, 874 void* data1, 875 void* data2); 876 void ctx_listen_with_finalize (Ctx *ctx, 877 CtxEventType types, 878 CtxCb cb, 879 void* data1, 880 void* data2, 881 void (*finalize)(void *listen_data, void 882 *listen_data2, 883 void *finalize_data), 884 void *finalize_data); 885 886 void ctx_init (int *argc, char ***argv); // is a no-op but could launch 887 // terminal 888 CtxEvent *ctx_get_event (Ctx *ctx); 889 int ctx_has_event (Ctx *ctx, int timeout); 890 void ctx_get_event_fds (Ctx *ctx, int *fd, int *count); 891 892 int ctx_pointer_is_down (Ctx *ctx, int no); 893 float ctx_pointer_x (Ctx *ctx); 894 float ctx_pointer_y (Ctx *ctx); 895 void ctx_freeze (Ctx *ctx); 896 void ctx_thaw (Ctx *ctx); 897 int ctx_events_frozen (Ctx *ctx); 898 void ctx_events_clear_items (Ctx *ctx); 899 int ctx_events_width (Ctx *ctx); 900 int ctx_events_height (Ctx *ctx); 901 902 /* The following functions drive the event delivery, registered callbacks 903 * are called in response to these being called. 904 */ 905 906 int ctx_key_down (Ctx *ctx, unsigned int keyval, 907 const char *string, uint32_t time); 908 int ctx_key_up (Ctx *ctx, unsigned int keyval, 909 const char *string, uint32_t time); 910 int ctx_key_press (Ctx *ctx, unsigned int keyval, 911 const char *string, uint32_t time); 912 913 914 int ctx_scrolled (Ctx *ctx, float x, float y, CtxScrollDirection 915 scroll_direction, uint32_t time); 916 void ctx_incoming_message (Ctx *ctx, const char *message, long time); 917 int ctx_pointer_motion (Ctx *ctx, float x, float y, int device_no, 918 uint32_t time); 919 int ctx_pointer_release (Ctx *ctx, float x, float y, int device_no, 920 uint32_t time); 921 int ctx_pointer_press (Ctx *ctx, float x, float y, int device_no, 922 uint32_t time); 923 int ctx_pointer_drop (Ctx *ctx, float x, float y, int device_no, 924 uint32_t time, 925 char *string); 926 927 typedef enum 928 { 929 CTX_CONT = '\0', // - contains args from preceding entry 930 CTX_NOP = ' ', // 931 CTX_DATA = '(', // size size-in-entries - u32 932 CTX_DATA_REV = ')', // reverse traversal data marker 933 CTX_SET_RGBA_U8 = '*', // r g b a - u8 934 CTX_NEW_EDGE = '+', // x0 y0 x1 y1 - s16 935 // set pixel might want a shorter ascii form? or keep it an embedded 936 // only option? 937 CTX_SET_PIXEL = '-', // 8bit "fast-path" r g b a x y - u8 for rgba, 938 and u16 for x,y 939 /* optimizations that reduce the number of entries used, 940 * not visible outside the drawlist compression, thus 941 * using entries that cannot be used directly as commands 942 * since they would be interpreted as numbers - if values>127 943 * then the embedded font data is harder to escape. 944 */ 945 CTX_REL_LINE_TO_X4 = '0', // x1 y1 x2 y2 x3 y3 x4 y4 -- s8 946 CTX_REL_LINE_TO_REL_CURVE_TO = '1', // x1 y1 cx1 cy1 cx2 cy2 x y -- s8 947 CTX_REL_CURVE_TO_REL_LINE_TO = '2', // cx1 cy1 cx2 cy2 x y x1 y1 -- s8 948 CTX_REL_CURVE_TO_REL_MOVE_TO = '3', // cx1 cy1 cx2 cy2 x y x1 y1 -- s8 949 CTX_REL_LINE_TO_X2 = '4', // x1 y1 x2 y2 -- s16 950 CTX_MOVE_TO_REL_LINE_TO = '5', // x1 y1 x2 y2 -- s16 951 CTX_REL_LINE_TO_REL_MOVE_TO = '6', // x1 y1 x2 y2 -- s16 952 CTX_FILL_MOVE_TO = '7', // x y 953 CTX_REL_QUAD_TO_REL_QUAD_TO = '8', // cx1 x1 cy1 y1 cx1 x2 cy1 y1 -- s8 954 CTX_REL_QUAD_TO_S16 = '9', // cx1 cy1 x y - s16 955 // expand with: . : 956 CTX_FLUSH = ';', 957 958 CTX_DEFINE_GLYPH = '@', // unichar width - u32 959 CTX_ARC_TO = 'A', // x1 y1 x2 y2 radius 960 CTX_ARC = 'B', // x y radius angle1 angle2 direction 961 CTX_CURVE_TO = 'C', // cx1 cy1 cx2 cy2 x y 962 CTX_STROKE = 'E', // 963 CTX_FILL = 'F', // 964 CTX_RESTORE = 'G', // 965 CTX_HOR_LINE_TO = 'H', // x 966 CTX_DEFINE_TEXTURE = 'I', // "eid" width height format "data" 967 CTX_ROTATE = 'J', // radians 968 CTX_COLOR = 'K', // model, c1 c2 c3 ca - has a variable set of 969 // arguments. 970 CTX_LINE_TO = 'L', // x y 971 CTX_MOVE_TO = 'M', // x y 972 CTX_BEGIN_PATH = 'N', // 973 CTX_SCALE = 'O', // xscale yscale 974 CTX_NEW_PAGE = 'P', // - NYI - optional page-size 975 CTX_QUAD_TO = 'Q', // cx cy x y 976 CTX_VIEW_BOX = 'R', // x y width height 977 CTX_SMOOTH_TO = 'S', // cx cy x y 978 CTX_SMOOTHQ_TO = 'T', // x y 979 CTX_RESET = 'U', // 980 CTX_VER_LINE_TO = 'V', // y 981 CTX_APPLY_TRANSFORM = 'W', // a b c d e f - for set_transform combine 982 with identity 983 CTX_EXIT = 'X', // 984 CTX_ROUND_RECTANGLE = 'Y', // x y width height radius 985 986 CTX_CLOSE_PATH2 = 'Z', // 987 CTX_STROKE_SOURCE = '_', // next source definition applies to strokes 988 CTX_KERNING_PAIR = '[', // glA glB kerning, glA and glB in u16 989 kerning in s32 990 CTX_COLOR_SPACE = ']', // IccSlot data data_len, 991 // data can be a string with a name, 992 // icc data or perhaps our own serialization 993 // of profile data 994 CTX_REL_ARC_TO = 'a', // x1 y1 x2 y2 radius 995 CTX_CLIP = 'b', 996 CTX_REL_CURVE_TO = 'c', // cx1 cy1 cx2 cy2 x y 997 CTX_LINE_DASH = 'd', // dashlen0 [dashlen1 ...] 998 CTX_TRANSLATE = 'e', // x y 999 CTX_LINEAR_GRADIENT = 'f', // x1 y1 x2 y2 1000 CTX_SAVE = 'g', 1001 CTX_REL_HOR_LINE_TO = 'h', // x 1002 CTX_TEXTURE = 'i', 1003 CTX_PRESERVE = 'j', // 1004 CTX_SET_KEY = 'k', // - used together with another char to 1005 identify 1006 // a key to set 1007 CTX_REL_LINE_TO = 'l', // x y 1008 CTX_REL_MOVE_TO = 'm', // x y 1009 CTX_FONT = 'n', // as used by text parser 1010 CTX_RADIAL_GRADIENT = 'o', // x1 y1 radius1 x2 y2 radius2 1011 CTX_GRADIENT_STOP = 'p', // argument count depends on current color 1012 model 1013 CTX_REL_QUAD_TO = 'q', // cx cy x y 1014 CTX_RECTANGLE = 'r', // x y width height 1015 CTX_REL_SMOOTH_TO = 's', // cx cy x y 1016 CTX_REL_SMOOTHQ_TO = 't', // x y 1017 CTX_STROKE_TEXT = 'u', // string - utf8 string 1018 CTX_REL_VER_LINE_TO = 'v', // y 1019 CTX_GLYPH = 'w', // unichar fontsize 1020 CTX_TEXT = 'x', // string | kern - utf8 data to shape or 1021 horizontal kerning amount 1022 CTX_IDENTITY = 'y', // 1023 CTX_CLOSE_PATH = 'z', // 1024 CTX_START_GROUP = '{', 1025 CTX_END_GROUP = '}', 1026 CTX_SOURCE_TRANSFORM = '`', 1027 1028 CTX_EDGE = '&', // will not occur in 1029 commandstream 1030 CTX_EDGE_FLIPPED = '^', // x0 y0 x1 y1 - s16 // thus these use 1031 reserved entries as code 1032 1033 /* though expressed as two chars in serialization we have 1034 * dedicated byte commands for the setters to keep the dispatch 1035 * simpler. There is no need for these to be human readable thus we go > 1036 128 1037 * 1038 * unused: !&<=>?:.=/\`, 1039 * reserved: '"& # %^@ 1040 */ 1041 1042 1043 CTX_FILL_RULE = 128, // kr rule - u8, default = 1044 CTX_FILLE_RULE_EVEN_ODD 1045 CTX_BLEND_MODE = 129, // kB mode - u8 , default=0 1046 1047 CTX_MITER_LIMIT = 130, // km limit - float, default = 0.0 1048 1049 CTX_LINE_JOIN = 131, // kj join - u8 , default=0 1050 CTX_LINE_CAP = 132, // kc cap - u8, default = 0 1051 CTX_LINE_WIDTH = 133, // kw width, default = 2.0 1052 CTX_GLOBAL_ALPHA = 134, // ka alpha - default=1.0 1053 CTX_COMPOSITING_MODE = 135, // kc mode - u8 , default=0 1054 1055 CTX_FONT_SIZE = 136, // kf size - float, default=? 1056 CTX_TEXT_ALIGN = 137, // kt align - u8, default = 1057 CTX_TEXT_ALIGN_START 1058 CTX_TEXT_BASELINE = 138, // kb baseline - u8, default = 1059 CTX_TEXT_ALIGN_ALPHABETIC 1060 CTX_TEXT_DIRECTION = 139, // kd 1061 1062 CTX_SHADOW_BLUR = 140, // ks 1063 CTX_SHADOW_COLOR = 141, // kC 1064 CTX_SHADOW_OFFSET_X = 142, // kx 1065 CTX_SHADOW_OFFSET_Y = 143, // ky 1066 CTX_IMAGE_SMOOTHING = 144, // kS 1067 CTX_LINE_DASH_OFFSET = 145, // kD lineDashOffset 1068 1069 // items marked with % are currently only for the parser 1070 // for instance for svg compatibility or simulated/converted color spaces 1071 // not the serialization/internal render stream 1072 // 1073 CTX_STROKE_RECT = 200, // strokeRect - only exist in long form 1074 CTX_FILL_RECT = 201, // fillRect - only exist in long form 1075 } CtxCode; 1076 1077 1078 #pragma pack(push,1) 1079 1080 typedef struct _CtxCommand CtxCommand; 1081 typedef struct _CtxIterator CtxIterator; 1082 1083 CtxIterator * 1084 ctx_current_path (Ctx *ctx); 1085 void 1086 ctx_path_extents (Ctx *ctx, float *ex1, float *ey1, float *ex2, float *ey2); 1087 1088 #define CTX_ASSERT 0 1089 1090 #if CTX_ASSERT==1 1091 #define ctx_assert(a) if(!(a)){fprintf(stderr,"%s:%i assertion failed\n", 1092 __FUNCTION__, __LINE__); } 1093 #else 1094 #define ctx_assert(a) 1095 #endif 1096 1097 int ctx_get_drawlist_count (Ctx *ctx); 1098 1099 struct 1100 _CtxCommand 1101 { 1102 union 1103 { 1104 uint8_t code; 1105 CtxEntry entry; 1106 struct 1107 { 1108 uint8_t code; 1109 float scalex; 1110 float scaley; 1111 } scale; 1112 struct 1113 { 1114 uint8_t code; 1115 uint32_t stringlen; 1116 uint32_t blocklen; 1117 uint8_t cont; 1118 uint8_t data[8]; /* ... and continues */ 1119 } data; 1120 struct 1121 { 1122 uint8_t code; 1123 uint32_t stringlen; 1124 uint32_t blocklen; 1125 } data_rev; 1126 struct 1127 { 1128 uint8_t code; 1129 float pad; 1130 float pad2; 1131 uint8_t code_data; 1132 uint32_t stringlen; 1133 uint32_t blocklen; 1134 uint8_t code_cont; 1135 uint8_t utf8[8]; /* .. and continues */ 1136 } text; 1137 struct 1138 { 1139 uint8_t code; 1140 uint32_t key_hash; 1141 float pad; 1142 uint8_t code_data; 1143 uint32_t stringlen; 1144 uint32_t blocklen; 1145 uint8_t code_cont; 1146 uint8_t utf8[8]; /* .. and continues */ 1147 } set; 1148 struct 1149 { 1150 uint8_t code; 1151 uint32_t pad0; 1152 float pad1; 1153 uint8_t code_data; 1154 uint32_t stringlen; 1155 uint32_t blocklen; 1156 uint8_t code_cont; 1157 uint8_t utf8[8]; /* .. and continues */ 1158 } get; 1159 struct { 1160 uint8_t code; 1161 uint32_t count; /* better than byte_len in code, but needs to then be 1162 set */ 1163 float pad1; 1164 uint8_t code_data; 1165 uint32_t byte_len; 1166 uint32_t blocklen; 1167 uint8_t code_cont; 1168 float data[2]; /* .. and - possibly continues */ 1169 } line_dash; 1170 struct { 1171 uint8_t code; 1172 uint32_t space_slot; 1173 float pad1; 1174 uint8_t code_data; 1175 uint32_t data_len; 1176 uint32_t blocklen; 1177 uint8_t code_cont; 1178 uint8_t data[8]; /* .. and continues */ 1179 } colorspace; 1180 struct 1181 { 1182 uint8_t code; 1183 float x; 1184 float y; 1185 uint8_t code_data; 1186 uint32_t stringlen; 1187 uint32_t blocklen; 1188 uint8_t code_cont; 1189 char eid[8]; /* .. and continues */ 1190 } texture; 1191 struct 1192 { 1193 uint8_t code; 1194 uint32_t width; 1195 uint32_t height; 1196 uint8_t code_cont0; 1197 uint16_t format; 1198 uint16_t pad0; 1199 uint32_t pad1; 1200 uint8_t code_data; 1201 uint32_t stringlen; 1202 uint32_t blocklen; 1203 uint8_t code_cont1; 1204 char eid[8]; /* .. and continues */ 1205 // followed by - in variable offset code_Data, data_len, 1206 datablock_len, cont, pixeldata 1207 } define_texture; 1208 struct 1209 { 1210 uint8_t code; 1211 float pad; 1212 float pad2; 1213 uint8_t code_data; 1214 uint32_t stringlen; 1215 uint32_t blocklen; 1216 uint8_t code_cont; 1217 uint8_t utf8[8]; /* .. and continues */ 1218 } text_stroke; 1219 struct 1220 { 1221 uint8_t code; 1222 float pad; 1223 float pad2; 1224 uint8_t code_data; 1225 uint32_t stringlen; 1226 uint32_t blocklen; 1227 uint8_t code_cont; 1228 uint8_t utf8[8]; /* .. and continues */ 1229 } set_font; 1230 struct 1231 { 1232 uint8_t code; 1233 float model; 1234 float r; 1235 uint8_t pad1; 1236 float g; 1237 float b; 1238 uint8_t pad2; 1239 float a; 1240 } rgba; 1241 struct 1242 { 1243 uint8_t code; 1244 float model; 1245 float c; 1246 uint8_t pad1; 1247 float m; 1248 float y; 1249 uint8_t pad2; 1250 float k; 1251 float a; 1252 } cmyka; 1253 struct 1254 { 1255 uint8_t code; 1256 float model; 1257 float g; 1258 uint8_t pad1; 1259 float a; 1260 } graya; 1261 1262 struct 1263 { 1264 uint8_t code; 1265 float model; 1266 float c0; 1267 uint8_t pad1; 1268 float c1; 1269 float c2; 1270 uint8_t pad2; 1271 float c3; 1272 float c4; 1273 uint8_t pad3; 1274 float c5; 1275 float c6; 1276 uint8_t pad4; 1277 float c7; 1278 float c8; 1279 uint8_t pad5; 1280 float c9; 1281 float c10; 1282 } set_color; 1283 struct 1284 { 1285 uint8_t code; 1286 float x; 1287 float y; 1288 } rel_move_to; 1289 struct 1290 { 1291 uint8_t code; 1292 float x; 1293 float y; 1294 } rel_line_to; 1295 struct 1296 { 1297 uint8_t code; 1298 float x; 1299 float y; 1300 } line_to; 1301 struct 1302 { 1303 uint8_t code; 1304 float cx1; 1305 float cy1; 1306 uint8_t pad0; 1307 float cx2; 1308 float cy2; 1309 uint8_t pad1; 1310 float x; 1311 float y; 1312 } rel_curve_to; 1313 struct 1314 { 1315 uint8_t code; 1316 float x; 1317 float y; 1318 } move_to; 1319 struct 1320 { 1321 uint8_t code; 1322 float cx1; 1323 float cy1; 1324 uint8_t pad0; 1325 float cx2; 1326 float cy2; 1327 uint8_t pad1; 1328 float x; 1329 float y; 1330 } curve_to; 1331 struct 1332 { 1333 uint8_t code; 1334 float x1; 1335 float y1; 1336 uint8_t pad0; 1337 float r1; 1338 float x2; 1339 uint8_t pad1; 1340 float y2; 1341 float r2; 1342 } radial_gradient; 1343 struct 1344 { 1345 uint8_t code; 1346 float x1; 1347 float y1; 1348 uint8_t pad0; 1349 float x2; 1350 float y2; 1351 } linear_gradient; 1352 struct 1353 { 1354 uint8_t code; 1355 float x; 1356 float y; 1357 uint8_t pad0; 1358 float width; 1359 float height; 1360 uint8_t pad1; 1361 float radius; 1362 } rectangle; 1363 struct { 1364 uint8_t code; 1365 float x; 1366 float y; 1367 uint8_t pad0; 1368 float width; 1369 float height; 1370 } view_box; 1371 1372 struct 1373 { 1374 uint8_t code; 1375 uint16_t glyph_before; 1376 uint16_t glyph_after; 1377 int32_t amount; 1378 } kern; 1379 1380 struct 1381 { 1382 uint8_t code; 1383 uint32_t glyph; 1384 uint32_t advance; // * 256 1385 } define_glyph; 1386 1387 struct 1388 { 1389 uint8_t code; 1390 uint8_t rgba[4]; 1391 uint16_t x; 1392 uint16_t y; 1393 } set_pixel; 1394 struct 1395 { 1396 uint8_t code; 1397 float cx; 1398 float cy; 1399 uint8_t pad0; 1400 float x; 1401 float y; 1402 } quad_to; 1403 struct 1404 { 1405 uint8_t code; 1406 float cx; 1407 float cy; 1408 uint8_t pad0; 1409 float x; 1410 float y; 1411 } rel_quad_to; 1412 struct 1413 { 1414 uint8_t code; 1415 float x; 1416 float y; 1417 uint8_t pad0; 1418 float radius; 1419 float angle1; 1420 uint8_t pad1; 1421 float angle2; 1422 float direction; 1423 } 1424 arc; 1425 struct 1426 { 1427 uint8_t code; 1428 float x1; 1429 float y1; 1430 uint8_t pad0; 1431 float x2; 1432 float y2; 1433 uint8_t pad1; 1434 float radius; 1435 } 1436 arc_to; 1437 /* some format specific generic accesors: */ 1438 struct 1439 { 1440 uint8_t code; 1441 float x0; 1442 float y0; 1443 uint8_t pad0; 1444 float x1; 1445 float y1; 1446 uint8_t pad1; 1447 float x2; 1448 float y2; 1449 uint8_t pad2; 1450 float x3; 1451 float y3; 1452 uint8_t pad3; 1453 float x4; 1454 float y4; 1455 } c; 1456 struct 1457 { 1458 uint8_t code; 1459 float a0; 1460 float a1; 1461 uint8_t pad0; 1462 float a2; 1463 float a3; 1464 uint8_t pad1; 1465 float a4; 1466 float a5; 1467 uint8_t pad2; 1468 float a6; 1469 float a7; 1470 uint8_t pad3; 1471 float a8; 1472 float a9; 1473 } f; 1474 struct 1475 { 1476 uint8_t code; 1477 uint32_t a0; 1478 uint32_t a1; 1479 uint8_t pad0; 1480 uint32_t a2; 1481 uint32_t a3; 1482 uint8_t pad1; 1483 uint32_t a4; 1484 uint32_t a5; 1485 uint8_t pad2; 1486 uint32_t a6; 1487 uint32_t a7; 1488 uint8_t pad3; 1489 uint32_t a8; 1490 uint32_t a9; 1491 } u32; 1492 struct 1493 { 1494 uint8_t code; 1495 uint64_t a0; 1496 uint8_t pad0; 1497 uint64_t a1; 1498 uint8_t pad1; 1499 uint64_t a2; 1500 uint8_t pad2; 1501 uint64_t a3; 1502 uint8_t pad3; 1503 uint64_t a4; 1504 } u64; 1505 struct 1506 { 1507 uint8_t code; 1508 int32_t a0; 1509 int32_t a1; 1510 uint8_t pad0; 1511 int32_t a2; 1512 int32_t a3; 1513 uint8_t pad1; 1514 int32_t a4; 1515 int32_t a5; 1516 uint8_t pad2; 1517 int32_t a6; 1518 int32_t a7; 1519 uint8_t pad3; 1520 int32_t a8; 1521 int32_t a9; 1522 } s32; 1523 struct 1524 { 1525 uint8_t code; 1526 int16_t a0; 1527 int16_t a1; 1528 int16_t a2; 1529 int16_t a3; 1530 uint8_t pad0; 1531 int16_t a4; 1532 int16_t a5; 1533 int16_t a6; 1534 int16_t a7; 1535 uint8_t pad1; 1536 int16_t a8; 1537 int16_t a9; 1538 int16_t a10; 1539 int16_t a11; 1540 uint8_t pad2; 1541 int16_t a12; 1542 int16_t a13; 1543 int16_t a14; 1544 int16_t a15; 1545 uint8_t pad3; 1546 int16_t a16; 1547 int16_t a17; 1548 int16_t a18; 1549 int16_t a19; 1550 } s16; 1551 struct 1552 { 1553 uint8_t code; 1554 uint16_t a0; 1555 uint16_t a1; 1556 uint16_t a2; 1557 uint16_t a3; 1558 uint8_t pad0; 1559 uint16_t a4; 1560 uint16_t a5; 1561 uint16_t a6; 1562 uint16_t a7; 1563 uint8_t pad1; 1564 uint16_t a8; 1565 uint16_t a9; 1566 uint16_t a10; 1567 uint16_t a11; 1568 uint8_t pad2; 1569 uint16_t a12; 1570 uint16_t a13; 1571 uint16_t a14; 1572 uint16_t a15; 1573 uint8_t pad3; 1574 uint16_t a16; 1575 uint16_t a17; 1576 uint16_t a18; 1577 uint16_t a19; 1578 } u16; 1579 struct 1580 { 1581 uint8_t code; 1582 uint8_t a0; 1583 uint8_t a1; 1584 uint8_t a2; 1585 uint8_t a3; 1586 uint8_t a4; 1587 uint8_t a5; 1588 uint8_t a6; 1589 uint8_t a7; 1590 uint8_t pad0; 1591 uint8_t a8; 1592 uint8_t a9; 1593 uint8_t a10; 1594 uint8_t a11; 1595 uint8_t a12; 1596 uint8_t a13; 1597 uint8_t a14; 1598 uint8_t a15; 1599 uint8_t pad1; 1600 uint8_t a16; 1601 uint8_t a17; 1602 uint8_t a18; 1603 uint8_t a19; 1604 uint8_t a20; 1605 uint8_t a21; 1606 uint8_t a22; 1607 uint8_t a23; 1608 } u8; 1609 struct 1610 { 1611 uint8_t code; 1612 int8_t a0; 1613 int8_t a1; 1614 int8_t a2; 1615 int8_t a3; 1616 int8_t a4; 1617 int8_t a5; 1618 int8_t a6; 1619 int8_t a7; 1620 uint8_t pad0; 1621 int8_t a8; 1622 int8_t a9; 1623 int8_t a10; 1624 int8_t a11; 1625 int8_t a12; 1626 int8_t a13; 1627 int8_t a14; 1628 int8_t a15; 1629 uint8_t pad1; 1630 int8_t a16; 1631 int8_t a17; 1632 int8_t a18; 1633 int8_t a19; 1634 int8_t a20; 1635 int8_t a21; 1636 int8_t a22; 1637 int8_t a23; 1638 } s8; 1639 }; 1640 CtxEntry next_entry; // also pads size of CtxCommand slightly. 1641 }; 1642 1643 typedef struct _CtxImplementation CtxImplementation; 1644 struct _CtxImplementation 1645 { 1646 void (*process) (void *renderer, CtxCommand *entry); 1647 void (*reset) (void *renderer); 1648 void (*flush) (void *renderer); 1649 char *(*get_clipboard) (void *ctxctx); 1650 void (*set_clipboard) (void *ctxctx, const char *text); 1651 void (*free) (void *renderer); 1652 }; 1653 1654 CtxCommand *ctx_iterator_next (CtxIterator *iterator); 1655 1656 #define ctx_arg_string() ((char*)&entry[2].data.u8[0]) 1657 1658 1659 /* The above should be public API 1660 */ 1661 1662 #pragma pack(pop) 1663 1664 /* access macros for nth argument of a given type when packed into 1665 * an CtxEntry pointer in current code context 1666 */ 1667 #define ctx_arg_float(no) entry[(no)>>1].data.f[(no)&1] 1668 #define ctx_arg_u64(no) entry[(no)].data.u64[0] 1669 #define ctx_arg_u32(no) entry[(no)>>1].data.u32[(no)&1] 1670 #define ctx_arg_s32(no) entry[(no)>>1].data.s32[(no)&1] 1671 #define ctx_arg_u16(no) entry[(no)>>2].data.u16[(no)&3] 1672 #define ctx_arg_s16(no) entry[(no)>>2].data.s16[(no)&3] 1673 #define ctx_arg_u8(no) entry[(no)>>3].data.u8[(no)&7] 1674 #define ctx_arg_s8(no) entry[(no)>>3].data.s8[(no)&7] 1675 #define ctx_arg_string() ((char*)&entry[2].data.u8[0]) 1676 1677 typedef enum 1678 { 1679 CTX_GRAY = 1, 1680 CTX_RGB = 3, 1681 CTX_DRGB = 4, 1682 CTX_CMYK = 5, 1683 CTX_DCMYK = 6, 1684 CTX_LAB = 7, 1685 CTX_LCH = 8, 1686 CTX_GRAYA = 101, 1687 CTX_RGBA = 103, 1688 CTX_DRGBA = 104, 1689 CTX_CMYKA = 105, 1690 CTX_DCMYKA = 106, 1691 CTX_LABA = 107, 1692 CTX_LCHA = 108, 1693 CTX_GRAYA_A = 201, 1694 CTX_RGBA_A = 203, 1695 CTX_RGBA_A_DEVICE = 204, 1696 CTX_CMYKA_A = 205, 1697 CTX_DCMYKA_A = 206, 1698 // RGB device and RGB ? 1699 } CtxColorModel; 1700 1701 enum _CtxAntialias 1702 { 1703 CTX_ANTIALIAS_DEFAULT, // fast - suitable for realtime UI 1704 CTX_ANTIALIAS_NONE, // non-antialiased 1705 CTX_ANTIALIAS_FAST, // aa 3 // deprected or is default equal to this 1706 now? 1707 CTX_ANTIALIAS_GOOD, // aa 5 // this should perhaps still be 5? 1708 CTX_ANTIALIAS_BEST // aa 17 // accurate-suitable for saved assets 1709 }; 1710 typedef enum _CtxAntialias CtxAntialias; 1711 1712 enum _CtxCursor 1713 { 1714 CTX_CURSOR_UNSET, 1715 CTX_CURSOR_NONE, 1716 CTX_CURSOR_ARROW, 1717 CTX_CURSOR_IBEAM, 1718 CTX_CURSOR_WAIT, 1719 CTX_CURSOR_HAND, 1720 CTX_CURSOR_CROSSHAIR, 1721 CTX_CURSOR_RESIZE_ALL, 1722 CTX_CURSOR_RESIZE_N, 1723 CTX_CURSOR_RESIZE_S, 1724 CTX_CURSOR_RESIZE_E, 1725 CTX_CURSOR_RESIZE_NE, 1726 CTX_CURSOR_RESIZE_SE, 1727 CTX_CURSOR_RESIZE_W, 1728 CTX_CURSOR_RESIZE_NW, 1729 CTX_CURSOR_RESIZE_SW, 1730 CTX_CURSOR_MOVE 1731 }; 1732 typedef enum _CtxCursor CtxCursor; 1733 1734 /* to be used immediately after a ctx_listen or ctx_listen_full causing the 1735 * cursor to change when hovering the listen area. 1736 */ 1737 void ctx_listen_set_cursor (Ctx *ctx, 1738 CtxCursor cursor); 1739 1740 /* lower level cursor setting that is independent of ctx event handling 1741 */ 1742 void ctx_set_cursor (Ctx *ctx, CtxCursor cursor); 1743 CtxCursor ctx_get_cursor (Ctx *ctx); 1744 void ctx_set_antialias (Ctx *ctx, CtxAntialias antialias); 1745 CtxAntialias ctx_get_antialias (Ctx *ctx); 1746 void ctx_set_render_threads (Ctx *ctx, int n_threads); 1747 int ctx_get_render_threads (Ctx *ctx); 1748 1749 void ctx_set_hash_cache (Ctx *ctx, int enable_hash_cache); 1750 int ctx_get_hash_cache (Ctx *ctx); 1751 1752 1753 typedef struct _CtxParser CtxParser; 1754 CtxParser *ctx_parser_new ( 1755 Ctx *ctx, 1756 int width, 1757 int height, 1758 float cell_width, 1759 float cell_height, 1760 int cursor_x, 1761 int cursor_y, 1762 int (*set_prop)(void *prop_data, uint64_t key, const char *data, int 1763 len), 1764 int (*get_prop)(void *prop_Data, const char *key, char **data, int *len) 1765 , 1766 void *prop_data, 1767 void (*exit) (void *exit_data), 1768 void *exit_data); 1769 1770 1771 enum _CtxColorSpace 1772 { 1773 CTX_COLOR_SPACE_DEVICE_RGB, 1774 CTX_COLOR_SPACE_DEVICE_CMYK, 1775 CTX_COLOR_SPACE_USER_RGB, 1776 CTX_COLOR_SPACE_USER_CMYK, 1777 CTX_COLOR_SPACE_TEXTURE 1778 }; 1779 typedef enum _CtxColorSpace CtxColorSpace; 1780 1781 /* sets the color space for a slot, the space is either a string of 1782 * "sRGB" "rec2020" .. etc or an icc profile. 1783 * 1784 * The slots device_rgb and device_cmyk is mostly to be handled outside 1785 drawing 1786 * code, and user_rgb and user_cmyk is to be used. With no user_cmyk set 1787 * user_cmyk == device_cmyk. 1788 * 1789 * The set profiles follows the graphics state. 1790 */ 1791 void ctx_colorspace (Ctx *ctx, 1792 CtxColorSpace space_slot, 1793 unsigned char *data, 1794 int data_length); 1795 1796 void 1797 ctx_parser_set_size (CtxParser *parser, 1798 int width, 1799 int height, 1800 float cell_width, 1801 float cell_height); 1802 1803 void ctx_parser_feed_bytes (CtxParser *parser, const char *data, int count); 1804 1805 int 1806 ctx_get_contents (const char *path, 1807 unsigned char **contents, 1808 long *length); 1809 1810 void ctx_parser_free (CtxParser *parser); 1811 typedef struct _CtxSHA1 CtxSHA1; 1812 1813 void 1814 ctx_bin2base64 (const void *bin, 1815 int bin_length, 1816 char *ascii); 1817 int 1818 ctx_base642bin (const char *ascii, 1819 int *length, 1820 unsigned char *bin); 1821 1822 1823 struct 1824 _CtxMatrix 1825 { 1826 float m[3][2]; 1827 }; 1828 1829 void ctx_apply_matrix (Ctx *ctx, CtxMatrix *matrix); 1830 void ctx_matrix_apply_transform (const CtxMatrix *m, float *x, float *y); 1831 void ctx_matrix_invert (CtxMatrix *m); 1832 void ctx_matrix_identity (CtxMatrix *matrix); 1833 void ctx_matrix_scale (CtxMatrix *matrix, float x, float y); 1834 void ctx_matrix_rotate (CtxMatrix *matrix, float angle); 1835 void ctx_matrix_multiply (CtxMatrix *result, 1836 const CtxMatrix *t, 1837 const CtxMatrix *s); 1838 1839 1840 1841 1842 float ctx_term_get_cell_width (Ctx *ctx); 1843 float ctx_term_get_cell_height (Ctx *ctx); 1844 1845 1846 1847 1848 1849 #if 1 // CTX_VT 1850 1851 typedef struct _VT VT; 1852 void vt_feed_keystring (VT *vt, CtxEvent *event, const char *str); 1853 void vt_paste (VT *vt, const char *str); 1854 char *vt_get_selection (VT *vt); 1855 long vt_rev (VT *vt); 1856 int vt_has_blink (VT *vt); 1857 1858 int ctx_clients_need_redraw (Ctx *ctx); 1859 void ctx_clients_handle_events (Ctx *ctx); 1860 1861 1862 typedef struct _CtxBuffer CtxBuffer; 1863 CtxBuffer *ctx_buffer_new_for_data (void *data, int width, int height, 1864 int stride, 1865 CtxPixelFormat pixel_format, 1866 void (*freefunc) (void *pixels, void 1867 *user_data), 1868 void *user_data); 1869 1870 1871 1872 1873 1874 1875 1876 #endif 1877 1878 1879 #ifndef CTX_CODEC_CHAR 1880 //#define CTX_CODEC_CHAR '\035' 1881 //#define CTX_CODEC_CHAR 'a' 1882 #define CTX_CODEC_CHAR '\020' // datalink escape 1883 //#define CTX_CODEC_CHAR '^' 1884 #endif 1885 1886 #ifndef assert 1887 #define assert(a) 1888 #endif 1889 1890 #ifdef __cplusplus 1891 } 1892 #endif 1893 #endif 1894 #ifndef __CTX_H__ 1895 #define __CTX_H__ 1896 #ifndef _DEFAULT_SOURCE 1897 #define _DEFAULT_SOURCE 1898 #endif 1899 #ifndef _XOPEN_SOURCE 1900 #define _XOPEN_SOURCE 600 1901 #endif 1902 1903 #ifndef CTX_STRING_H 1904 #define CTX_STRING_H 1905 1906 typedef struct _CtxString CtxString; 1907 struct _CtxString 1908 { 1909 char *str; 1910 int length; 1911 int utf8_length; 1912 int allocated_length; 1913 int is_line; 1914 }; 1915 1916 CtxString *ctx_string_new_with_size (const char *initial, int 1917 initial_size); 1918 CtxString *ctx_string_new (const char *initial); 1919 char *ctx_string_dissolve (CtxString *string); 1920 void ctx_string_free (CtxString *string, int freealloc); 1921 const char *ctx_string_get (CtxString *string); 1922 uint32_t ctx_string_get_unichar (CtxString *string, int pos); 1923 int ctx_string_get_length (CtxString *string); 1924 int ctx_string_get_utf8length (CtxString *string); 1925 void ctx_string_set (CtxString *string, const char 1926 *new_string); 1927 void ctx_string_clear (CtxString *string); 1928 void ctx_string_append_str (CtxString *string, const char *str); 1929 void ctx_string_append_byte (CtxString *string, char val); 1930 void ctx_string_append_string (CtxString *string, CtxString 1931 *string2); 1932 void ctx_string_append_unichar (CtxString *string, unsigned int 1933 unichar); 1934 void ctx_string_append_data (CtxString *string, const char *data, 1935 int len); 1936 1937 void ctx_string_append_utf8char (CtxString *string, const char *str); 1938 void ctx_string_append_printf (CtxString *string, const char 1939 *format, ...); 1940 void ctx_string_replace_utf8 (CtxString *string, int pos, const 1941 char *new_glyph); 1942 void ctx_string_insert_utf8 (CtxString *string, int pos, const 1943 char *new_glyph); 1944 1945 void ctx_string_insert_unichar (CtxString *string, int pos, uint32_t 1946 unichar); 1947 void ctx_string_replace_unichar (CtxString *string, int pos, 1948 uint32_t unichar); 1949 void ctx_string_remove (CtxString *string, int pos); 1950 char *ctx_strdup_printf (const char *format, ...); 1951 1952 #ifndef TRUE 1953 #define TRUE 1 1954 #endif 1955 #ifndef FALSE 1956 #define FALSE 0 1957 #endif 1958 1959 #endif 1960 #ifndef _CTX_INTERNAL_FONT_ 1961 #define _CTX_INTERNAL_FONT_ 1962 1963 #ifndef CTX_FONT_ascii 1964 /* this is a ctx encoded font based on DejaVuSans.ttf */ 1965 /* CTX_SUBDIV:8 CTX_BAKE_FONT_SIZE:160 */ 1966 /* glyphs covered: 1967 1968 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi 1969 jklmnopqrstuvwxyz{|}~ */ 1970 static const struct __attribute__ ((packed)) {uint8_t code; uint32_t a; 1971 uint32_t b;} 1972 ctx_font_ascii[]={ 1973 {'@', 0x00000020, 0x00002bb0},/* x-advance: 43.687500 */ 1974 {'@', 0x00000021, 0x00003719},/* ! x-advance: 55.097656 */ 1975 {'M', 0x41a5e7f2, 0xc1886037}, 1976 {'l', 0x4159fc90, 0x00000000}, 1977 {'4', 0x00880000, 0x0000ff94}, 1978 {'6', 0xff780000, 0xfd670000}, 1979 {'l', 0x4159fc90, 0x00000000}, 1980 {'l', 0x00000000, 0x422fd6c4}, 1981 {'l', 0xbfabcfe0, 0x41bfad86}, 1982 {'l', 0xc12df5b2, 0x00000000}, 1983 {'l', 0xbfb46710, 0xc1bfad86}, 1984 {'l', 0x00000000, 0xc22fd6c4}, 1985 {'@', 0x00000022, 0x00003f38},/* " x-advance: 63.218750 */ 1986 {'M', 0x41c50c07, 0xc2c86716}, 1987 {'l', 0x00000000, 0x4214fe48}, 1988 {'4', 0x0000ffa5, 0xfed70000}, 1989 {'6', 0x0000005b, 0x000000ca}, 1990 {'l', 0x00000000, 0x4214fe48}, 1991 {'l', 0xc1368ce4, 0x00000000}, 1992 {'l', 0x00000000, 0xc214fe48}, 1993 {'l', 0x41368ce4, 0x00000000}, 1994 {'@', 0x00000023, 0x0000732a},/* # x-advance: 115.164062 */ 1995 {'M', 0x428c8973, 0xc271e113}, 1996 {'l', 0xc19c3dda, 0x00000000}, 1997 {'4', 0x00b3ffd3, 0x0000009d}, 1998 {'6', 0xff4d002c, 0xfecfffb0}, 1999 {'l', 0xc0df5b10, 0x41ded19c}, 2000 {'l', 0x419cc74c, 0x00000000}, 2001 {'l', 0x40e180e0, 0xc1ded19c}, 2002 {'l', 0x412bcfe8, 0x00000000}, 2003 {'l', 0xc0dd3540, 0x41ded19c}, 2004 {'l', 0x41a78448, 0x00000000}, 2005 {'l', 0x00000000, 0x41255e7c}, 2006 {'l', 0xc1bc74d4, 0x00000000}, 2007 {'l', 0xc0b01b80, 0x41b35430}, 2008 {'l', 0x41aabd00, 0x00000000}, 2009 {'l', 0x00000000, 0x41244b9a}, 2010 {'l', 0xc1bfad88, 0x00000000}, 2011 {'l', 0xc0df5b10, 0x41de4829}, 2012 {'l', 0xc12bcfe4, 0x00000000}, 2013 {'l', 0x40dd3540, 0xc1de4829}, 2014 {'l', 0xc19d50c0, 0x00000000}, 2015 {'l', 0xc0dd3540, 0x41de4829}, 2016 {'l', 0xc12ce2ca, 0x00000000}, 2017 {'l', 0x40df5b10, 0xc1de4829}, 2018 {'l', 0xc1a920a5, 0x00000000}, 2019 {'l', 0x00000000, 0xc1244b9a}, 2020 {'l', 0x41bcfe48, 0x00000000}, 2021 {'l', 0x40b46718, 0xc1b35430}, 2022 {'l', 0xc1ace2cb, 0x00000000}, 2023 {'l', 0x00000000, 0xc1255e7c}, 2024 {'l', 0x41c1d353, 0x00000000}, 2025 {'l', 0x40db0f78, 0xc1ded19c}, 2026 {'l', 0x412df5b0, 0x00000000}, 2027 {'@', 0x00000024, 0x00005773},/* $ x-advance: 87.449219 */ 2028 {'M', 0x4239c595, 0x41a19c59}, 2029 {'4', 0x0000ffcb, 0xff5f0000}, 2030 {'q', 0xc0e180d8, 0xbe09731d}, 2031 {0, 0xc16180dc, 0xbfce2cac}, 2032 {'9', 0xfff4ffc8, 0xffdcff8f}, 2033 {'l', 0x00000000, 0xc14149e1}, 2034 {'q', 0x40db0f76, 0x4089731e}, 2035 {0, 0x415d3543, 0x40d05278}, 2036 {'9', 0x00110038, 0x00110073}, 2037 {'l', 0x00000000, 0xc1f4d50c}, 2038 {'q', 0xc16d50c2, 0xc01aa180}, 2039 {0, 0xc1ace2cb, 0xc10301b8}, 2040 {'q', 0xc0d6c3de, 0xc0b8b2b0}, 2041 {0, 0xc0d6c3de, 0xc17d6c3c}, 2042 {'q', 0x00000000, 0xc12f0898}, 2043 {0, 0x40ea180e, 0xc189fc90}, 2044 {'9', 0xffce003a, 0xffc700a8}, 2045 {'4', 0xff820000, 0x00000035}, 2046 {'l', 0x00000000, 0x417920a8}, 2047 {'8', 0x0a600231, 0x165b082e}, 2048 {'l', 0x00000000, 0x413beb60}, 2049 {'8', 0xdea5ead4, 0xf2a0f4d2}, 2050 {'l', 0x00000000, 0x41e54302}, 2051 {'q', 0x4173c228, 0x401655f0}, 2052 {0, 0x41b35432, 0x41063a6c}, 2053 {'q', 0x40e5cc70, 0x40c149e0}, 2054 {0, 0x40e5cc70, 0x4184149e}, 2055 {'q', 0x00000000, 0x413579fc}, 2056 {0, 0xc0f4d510, 0x418f5b0f}, 2057 {'9', 0x0034ffc4, 0x003cff51}, 2058 {'6', 0x00a20000, 0xfdc1ffcb}, 2059 {'l', 0x00000000, 0xc1dc2258}, 2060 {'8', 0x23a106c2, 0x4be01ce0}, 2061 {'8', 0x471e2e00, 0x2561191e}, 2062 {'m', 0x40d6c3d8, 0x414e2cac}, 2063 {'l', 0x00000000, 0x41e87bb4}, 2064 {'8', 0xda66f744, 0xb322e322}, 2065 {'8', 0xb5dfd100, 0xd898e5e0}, 2066 {'@', 0x00000025, 0x0000829a},/* % x-advance: 130.601562 */ 2067 {'M', 0x42c7dda3, 0xc2306037}, 2068 {'8', 0x27b700d2, 0x6ee627e6}, 2069 {'8', 0x6e1a4500, 0x2749271a}, 2070 {'8', 0xd947002d, 0x921ad81a}, 2071 {'8', 0x92e6ba00, 0xd8b9d8e6}, 2072 {'m', 0x00000000, 0xc1086034}, 2073 {'q', 0x4129aa18, 0x00000000}, 2074 {0, 0x4186c3dc, 0x40ec3dd8}, 2075 {'q', 0x40c7bb50, 0x40ec3dd8}, 2076 {0, 0x40c7bb50, 0x419f768c}, 2077 {'q', 0x00000000, 0x4148ce2d}, 2078 {0, 0xc0c9e120, 0x419f768d}, 2079 {'q', 0xc0c7bb40, 0x40ea180d}, 2080 {0, 0xc1863a68, 0x40ea180d}, 2081 {'q', 0xc12bcfe8, 0x34000000}, 2082 {0, 0xc187d6c4, 0xc0ea180d}, 2083 {'q', 0xc0c7bb40, 0xc0ec3dda}, 2084 {0, 0xc0c7bb40, 0xc19f768d}, 2085 {'q', 0x00000000, 0xc149e114}, 2086 {0, 0x40c7bb40, 0xc19f768c}, 2087 {'9', 0xffc50032, 0xffc50087}, 2088 {'m', 0xc28a8603, 0xc2237d6c}, 2089 {'8', 0x28b700d2, 0x6de627e6}, 2090 {'8', 0x6e1a4600, 0x2749271a}, 2091 {'8', 0xd949002e, 0x921ad91a}, 2092 {'8', 0x93e6bb00, 0xd8b7d8e6}, 2093 {'m', 0x42726a86, 0xc1086038}, 2094 {'l', 0x412bcfe0, 0x00000000}, 2095 {'4', 0x033ffe0b, 0x0000ffab}, 2096 {'6', 0xfcc101f5, 0x0000fe1c}, 2097 {'q', 0x4129aa14, 0x00000000}, 2098 {0, 0x41874d50, 0x40ec3de0}, 2099 {'q', 0x40c9e110, 0x40ea1800}, 2100 {0, 0x40c9e110, 0x419eed18}, 2101 {'q', 0x00000000, 0x414af3f8}, 2102 {0, 0xc0c9e110, 0x41a00000}, 2103 {'q', 0xc0c7bb48, 0x40ea1808}, 2104 {0, 0xc1874d51, 0x40ea1808}, 2105 {'q', 0xc12abcfe, 0x00000000}, 2106 {0, 0xc1874d51, 0xc0ea1808}, 2107 {'q', 0xc0c59579, 0xc0ec3dd8}, 2108 {0, 0xc0c59579, 0xc1a00000}, 2109 {'q', 0x00000000, 0xc147bb48}, 2110 {0, 0x40c7bb47, 0xc19eed18}, 2111 {'q', 0x40c7bb46, 0xc0ec3de0}, 2112 {0, 0x4186c3de, 0xc0ec3de0}, 2113 {'@', 0x00000026, 0x00006b2e},/* & x-advance: 107.179688 */ 2114 {'M', 0x4205b0f7, 0xc257920a}, 2115 {'8', 0x56b92bd0, 0x5aea2aea}, 2116 {'q', 0x00000000, 0x411cc74e}, 2117 {0, 0x40e3a6a8, 0x41827845}, 2118 {'q', 0x40e3a6a8, 0x40d05278}, 2119 {0, 0x418ed19c, 0x40d05278}, 2120 {'8', 0xf05f0033, 0xcd53ef2c}, 2121 {'6', 0xfeddfee4, 0xffc4004b}, 2122 {'l', 0x42086037, 0x420b98e9}, 2123 {'q', 0x407d6c40, 0xc0bf2410}, 2124 {0, 0x40c59570, 0xc14c06e0}, 2125 {'9', 0xffca0011, 0xff8d0014}, 2126 {'l', 0x4147bb40, 0x00000000}, 2127 {'q', 0xbf4e2c80, 0x410dbeb8}, 2128 {0, 0xc0897310, 0x418c225c}, 2129 {'9', 0x0045ffe5, 0x0088ffb3}, 2130 {'4', 0x00990095, 0x0000ff79}, 2131 {'l', 0xc1198e98, 0xc11dda33}, 2132 {'q', 0xc0df5b10, 0x40bf2414}, 2133 {0, 0xc16a1810, 0x410ed19c}, 2134 {'q', 0xc0f4d510, 0x4038b2ae}, 2135 {0, 0xc1838b2c, 0x4038b2ae}, 2136 {'q', 0xc181655e, 0x34000000}, 2137 {0, 0xc1d38b2a, 0xc1131d35}, 2138 {'q', 0xc1244b99, 0xc114301c}, 2139 {0, 0xc1244b99, 0xc1bd87bb}, 2140 {'q', 0x00000000, 0xc109731e}, 2141 {0, 0x408fe482, 0xc180dbeb}, 2142 {'q', 0x408fe484, 0xc0f2af40}, 2143 {0, 0x4157d6c4, 0xc163a6a8}, 2144 {'8', 0xbdd9dfe7, 0xbef3dff3}, 2145 {'q', 0x00000000, 0xc12df5b0}, 2146 {0, 0x40ee63a4, 0xc18b98e8}, 2147 {'q', 0x40ee63a8, 0xc0d49e10}, 2148 {0, 0x419e63a6, 0xc0d49e10}, 2149 {'8', 0x0958002c, 0x1c5a092c}, 2150 {'l', 0x00000000, 0x41436fb0}, 2151 {'8', 0xdaa7e7d2, 0xf3b2f3d6}, 2152 {'8', 0x1ea500c8, 0x4cde1dde}, 2153 {'8', 0x370f1b00, 0x4d401b10}, 2154 {'@', 0x00000027, 0x000025c9},/* ' x-advance: 37.785156 */ 2155 {'M', 0x41c50c07, 0xc2c86716}, 2156 {'l', 0x00000000, 0x4214fe48}, 2157 {'l', 0xc1368ce3, 0x00000000}, 2158 {'l', 0x00000000, 0xc214fe48}, 2159 {'l', 0x41368ce3, 0x00000000}, 2160 {'@', 0x00000028, 0x0000359f},/* ( x-advance: 53.621094 */ 2161 {'M', 0x422a7844, 0xc2d09732}, 2162 {'q', 0xc10fe480, 0x4176fae0}, 2163 {0, 0xc155b0f6, 0x41f44b9c}, 2164 {'q', 0xc08b98e8, 0x41719c54}, 2165 {0, 0xc08b98e8, 0x41f4d50a}, 2166 {'q', 0x00000000, 0x41780dbe}, 2167 {0, 0x408b98e8, 0x41f5e7f2}, 2168 {'9', 0x00790023, 0x00f4006a}, 2169 {'l', 0xc12bcfe2, 0x00000000}, 2170 {'q', 0xc12112e6, 0xc17c5958}, 2171 {0, 0xc1719c5a, 0xc1f80dbf}, 2172 {'q', 0xc09eed18, 0xc173c224}, 2173 {0, 0xc09eed18, 0xc1f225cc}, 2174 {'q', 0x00000000, 0xc16f768c}, 2175 {0, 0x409eed18, 0xc1f112e6}, 2176 {'q', 0x409eed1c, 0xc172af40}, 2177 {0, 0x41719c5a, 0xc1f80dc0}, 2178 {'l', 0x412bcfe2, 0x00000000}, 2179 {'@', 0x00000029, 0x0000359f},/* ) x-advance: 53.621094 */ 2180 {'M', 0x41301b7d, 0xc2d09732}, 2181 {'l', 0x412bcfe5, 0x00000000}, 2182 {'q', 0x412112e6, 0x417d6c40}, 2183 {0, 0x41708972, 0x41f80dc0}, 2184 {'q', 0x40a112e8, 0x4172af40}, 2185 {0, 0x40a112e8, 0x41f112e6}, 2186 {'q', 0x00000000, 0x41708974}, 2187 {0, 0xc0a112e8, 0x41f225cc}, 2188 {'9', 0x0079ffd9, 0x00f8ff88}, 2189 {'l', 0xc12bcfe5, 0x00000000}, 2190 {'q', 0x410ed19d, 0xc175e7f3}, 2191 {0, 0x41549e11, 0xc1f44b99}, 2192 {'q', 0x408dbeb4, 0xc173c226}, 2193 {0, 0x408dbeb4, 0xc1f5e7f2}, 2194 {'q', 0x00000000, 0xc1780dc0}, 2195 {0, 0xc08dbeb4, 0xc1f4d50a}, 2196 {'q', 0xc08b98e8, 0xc1719c58}, 2197 {0, 0xc1549e11, 0xc1f44b9c}, 2198 {'@', 0x0000002a, 0x000044b9},/* * x-advance: 68.722656 */ 2199 {'M', 0x42814302, 0xc2a761ef}, 2200 {'l', 0xc1c0c070, 0x41505278}, 2201 {'l', 0x41c0c070, 0x41516560}, 2202 {'l', 0xc07920b0, 0x40d27848}, 2203 {'l', 0xc1b46716, 0xc159fc94}, 2204 {'l', 0x00000000, 0x41ca6a88}, 2205 {'l', 0xc0f4d50c, 0x00000000}, 2206 {'l', 0x00000000, 0xc1ca6a88}, 2207 {'l', 0xc1b46716, 0x4159fc94}, 2208 {'l', 0xc07920a8, 0xc0d27848}, 2209 {'l', 0x41c0c06e, 0xc1516560}, 2210 {'l', 0xc1c0c06e, 0xc1505278}, 2211 {'l', 0x407920a4, 0xc0d49e10}, 2212 {'l', 0x41b46716, 0x4159fc90}, 2213 {'l', 0x36000000, 0xc1ca6a84}, 2214 {'l', 0x40f4d50c, 0x00000000}, 2215 {'l', 0x00000000, 0x41ca6a84}, 2216 {'l', 0x41b46716, 0xc159fc90}, 2217 {'l', 0x407920b0, 0x40d49e10}, 2218 {'@', 0x0000002b, 0x0000732a},/* + x-advance: 115.164062 */ 2219 {'M', 0x427ce2ca, 0xc2ac5957}, 2220 {'l', 0x00000000, 0x421587ba}, 2221 {'l', 0x421587bc, 0x00000000}, 2222 {'l', 0x00000000, 0x41368ce4}, 2223 {'l', 0xc21587bc, 0x00000000}, 2224 {'l', 0x00000000, 0x421587bb}, 2225 {'l', 0xc1346714, 0x00000000}, 2226 {'l', 0x00000000, 0xc21587bb}, 2227 {'l', 0xc21587bb, 0x00000000}, 2228 {'l', 0xb5800000, 0xc1368ce4}, 2229 {'l', 0x421587bb, 0x00000000}, 2230 {'l', 0x00000000, 0xc21587ba}, 2231 {'l', 0x41346714, 0x00000000}, 2232 {'@', 0x0000002c, 0x00002bb0},/* , x-advance: 43.687500 */ 2233 {'M', 0x4180dbeb, 0xc1886037}, 2234 {'l', 0x416293c2, 0x00000000}, 2235 {'l', 0x00000000, 0x4138b2b0}, 2236 {'l', 0xc1301b7c, 0x41abcfe4}, 2237 {'l', 0xc10a8604, 0x00000000}, 2238 {'l', 0x40b01b7c, 0xc1abcfe4}, 2239 {'l', 0x00000000, 0xc138b2b0}, 2240 {'@', 0x0000002d, 0x00003198},/* - x-advance: 49.593750 */ 2241 {'M', 0x40d6c3dd, 0xc22c9e11}, 2242 {'l', 0x4210b2af, 0x00000000}, 2243 {'l', 0x00000000, 0x41301b7c}, 2244 {'l', 0xc210b2af, 0x00000000}, 2245 {'l', 0xb5c00000, 0xc1301b7c}, 2246 {'[', 0x0047002d, 0x00000508}, 2247 {'[', 0x004a002d, 0x000007a6}, 2248 {'[', 0x004f002d, 0x000003d3}, 2249 {'[', 0x0051002d, 0x00000508}, 2250 {'[', 0x006f002d, 0x0000028c}, 2251 {'@', 0x0000002e, 0x00002bb0},/* . x-advance: 43.687500 */ 2252 {'M', 0x416b2af4, 0xc1886037}, 2253 {'l', 0x416293c2, 0x00000000}, 2254 {'l', 0x00000000, 0x41886037}, 2255 {'l', 0xc16293c2, 0x00000000}, 2256 {'l', 0x00000000, 0xc1886037}, 2257 {'@', 0x0000002f, 0x00002e4f},/* / x-advance: 46.308594 */ 2258 {'M', 0x420b98e9, 0xc2c86716}, 2259 {'l', 0x41368ce4, 0x00000000}, 2260 {'l', 0xc20b98e9, 0x42e1e7f2}, 2261 {'l', 0xc1368ce4, 0xb5800000}, 2262 {'l', 0x420b98e9, 0xc2e1e7f2}, 2263 {'@', 0x00000030, 0x00005773},/* 0 x-advance: 87.449219 */ 2264 {'M', 0x422ec3dd, 0xc2b68ce3}, 2265 {'q', 0xc1278448, 0x00000000}, 2266 {0, 0xc17c5956, 0x41255e80}, 2267 {'q', 0xc0a7844c, 0x41244b98}, 2268 {0, 0xc0a7844c, 0x41f7844c}, 2269 {'q', 0x00000000, 0x41a4d50c}, 2270 {0, 0x40a7844c, 0x41f7844c}, 2271 {'q', 0x40a9aa1c, 0x41244b98}, 2272 {0, 0x417c5956, 0x41244b98}, 2273 {'q', 0x41289734, 0x00000000}, 2274 {0, 0x417c5958, 0xc1244b98}, 2275 {'q', 0x40a9aa18, 0xc1255e80}, 2276 {0, 0x40a9aa18, 0xc1f7844c}, 2277 {'q', 0x00000000, 0xc1a55e80}, 2278 {0, 0xc0a9aa18, 0xc1f7844c}, 2279 {'9', 0xffaeffd7, 0xffaeff82}, 2280 {'m', 0x00000000, 0xc12bcfe0}, 2281 {'q', 0x4186c3de, 0x00000000}, 2282 {0, 0x41cda33a, 0x4155b0f8}, 2283 {'q', 0x410ed198, 0x41549e10}, 2284 {0, 0x410ed198, 0x421aa180}, 2285 {'q', 0x00000000, 0x41ca6a86}, 2286 {0, 0xc10ed198, 0x421aa181}, 2287 {'q', 0xc10dbeb8, 0x41549e11}, 2288 {0, 0xc1cda33a, 0x41549e11}, 2289 {'q', 0xc186c3dd, 0xb4c00000}, 2290 {0, 0xc1ce2cab, 0xc1549e11}, 2291 {'q', 0xc10dbeb5, 0xc155b0f8}, 2292 {0, 0xc10dbeb5, 0xc21aa181}, 2293 {'q', 0x00000000, 0xc1caf3f8}, 2294 {0, 0x410dbeb5, 0xc21aa180}, 2295 {'q', 0x410ed19c, 0xc155b0f8}, 2296 {0, 0x41ce2cab, 0xc155b0f8}, 2297 {'@', 0x00000031, 0x00005773},/* 1 x-advance: 87.449219 */ 2298 {'M', 0x41886037, 0xc1368ce3}, 2299 {'l', 0x41b12e63, 0x00000000}, 2300 {'l', 0x00000000, 0xc298e2cb}, 2301 {'l', 0xc1c0c06e, 0x409aa180}, 2302 {'l', 0x35800000, 0xc1459578}, 2303 {'l', 0x41bfad88, 0xc09aa180}, 2304 {'l', 0x4158e9a8, 0x00000000}, 2305 {'l', 0x00000000, 0x42b1957a}, 2306 {'l', 0x41b12e64, 0xb6400000}, 2307 {'l', 0x00000000, 0x41368ce3}, 2308 {'l', 0xc266df5a, 0x00000000}, 2309 {'l', 0xb6000000, 0xc1368ce3}, 2310 {'@', 0x00000032, 0x00005773},/* 2 x-advance: 87.449219 */ 2311 {'M', 0x41d301b8, 0xc1368ce3}, 2312 {'l', 0x423d4302, 0x00000000}, 2313 {'4', 0x005b0000, 0x0000fe04}, 2314 {'l', 0xb6000000, 0xc1368ce3}, 2315 {'q', 0x40f6fad8, 0xc0ff920a}, 2316 {0, 0x41a80dbe, 0xc1ab4670}, 2317 {'q', 0x4155b0f6, 0xc157d6c4}, 2318 {0, 0x41863a6b, 0xc18b0f76}, 2319 {'8', 0x9e48c634, 0xb114d814}, 2320 {'q', 0x00000000, 0xc0ff9210}, 2321 {0, 0xc0b46718, 0xc1505278}, 2322 {'q', 0xc0b24148, 0xc0a112f0}, 2323 {0, 0xc1690528, 0xc0a112f0}, 2324 {'q', 0xc0cc06e0, 0x00000000}, 2325 {0, 0xc157d6c2, 0x400dbec0}, 2326 {'9', 0x0011ffc8, 0x0035ff88}, 2327 {'l', 0x00000000, 0xc15b0f78}, 2328 {'q', 0x410301b8, 0xc0527840}, 2329 {0, 0x4174d50c, 0xc09eed20}, 2330 {'q', 0x40e3a6a8, 0xbfd6c3c0}, 2331 {0, 0x41505278, 0xbfd6c3c0}, 2332 {'q', 0x417920a4, 0x00000000}, 2333 {0, 0x41c6a860, 0x40f920a0}, 2334 {'q', 0x41143018, 0x40f920b0}, 2335 {0, 0x41143018, 0x41a67168}, 2336 {'8', 0x5dee3100, 0x68bd2cee}, 2337 {'q', 0xbfd6c3e0, 0x3ff920c0}, 2338 {0, 0xc12abd00, 0x41346718}, 2339 {'q', 0xc10fe480, 0x4114301c}, 2340 {0, 0xc1caf3f8, 0x41cfc904}, 2341 {'@', 0x00000033, 0x00005773},/* 3 x-advance: 87.449219 */ 2342 {'M', 0x425f1656, 0xc2581b7d}, 2343 {'q', 0x411bb468, 0x40052780}, 2344 {0, 0x4172af40, 0x410a8604}, 2345 {'q', 0x40b01b80, 0x40d27840}, 2346 {0, 0x40b01b80, 0x4181eed1}, 2347 {'q', 0x00000000, 0x416d50c0}, 2348 {0, 0xc12338b8, 0x41b79fc8}, 2349 {'q', 0xc12338b0, 0x4101eed3}, 2350 {0, 0xc1e7f240, 0x4101eed3}, 2351 {'8', 0xf79800ce, 0xe292f6cb}, 2352 {'l', 0x00000000, 0xc151655e}, 2353 {'q', 0x40b46716, 0x40527844}, 2354 {0, 0x4145957b, 0x409eed18}, 2355 {'q', 0x40d6c3dc, 0x3fd6c3e0}, 2356 {0, 0x41606df6, 0x3fd6c3e0}, 2357 {'q', 0x414c06dc, 0x00000000}, 2358 {0, 0x419b2af2, 0xc0a112e6}, 2359 {'q', 0x40d6c3e0, 0xc0a112e6}, 2360 {0, 0x40d6c3e0, 0xc16a180d}, 2361 {'q', 0x00000000, 0xc10dbeb6}, 2362 {0, 0xc0c7bb48, 0xc15d3542}, 2363 {'9', 0xffd8ffcf, 0xffd8ff77}, 2364 {'4', 0x0000ffa3, 0xffa70000}, 2365 {'l', 0x41436fae, 0x00000000}, 2366 {'q', 0x41200000, 0x00000000}, 2367 {0, 0x4174d50c, 0xc07d6c40}, 2368 {'8', 0xa42ae02a, 0xa2d4c300}, 2369 {'q', 0xc0adf5b0, 0xc0852790}, 2370 {0, 0xc17a338c, 0xc0852790}, 2371 {'q', 0xc0b24148, 0x00000000}, 2372 {0, 0xc13f2414, 0x3f9aa180}, 2373 {'9', 0x0009ffcd, 0x001eff90}, 2374 {'l', 0x00000000, 0xc14149e0}, 2375 {'q', 0x40f6fad8, 0xc0097320}, 2376 {0, 0x4166df5a, 0xc04e2cc0}, 2377 {'q', 0x40d8e9ac, 0xbf897300}, 2378 {0, 0x414c06de, 0xbf897300}, 2379 {'q', 0x4176fad8, 0x00000000}, 2380 {0, 0x41c36fae, 0x40e180e0}, 2381 {'q', 0x410fe480, 0x40df5b10}, 2382 {0, 0x410fe480, 0x419768cc}, 2383 {'q', 0x00000000, 0x41052788}, 2384 {0, 0xc0987bb0, 0x416180dc}, 2385 {'q', 0xc0987bb0, 0x40b68ce8}, 2386 {0, 0xc158e9a8, 0x40fd6c40}, 2387 {'@', 0x00000034, 0x00005773},/* 4 x-advance: 87.449219 */ 2388 {'M', 0x424fc905, 0xc2b0c74d}, 2389 {'4', 0x01abfeef, 0x00000111}, 2390 {'6', 0xfe550000, 0xffa2ffe4}, 2391 {'l', 0x41886038, 0x00000000}, 2392 {'l', 0x00000000, 0x42829aa2}, 2393 {'l', 0x4164b990, 0xb6800000}, 2394 {'l', 0x00000000, 0x41346714}, 2395 {'l', 0xc164b990, 0x00000000}, 2396 {'l', 0x00000000, 0x41bcfe48}, 2397 {'l', 0xc157d6c4, 0x00000000}, 2398 {'l', 0x00000000, 0xc1bcfe48}, 2399 {'l', 0xc234f089, 0x00000000}, 2400 {'l', 0xb5c00000, 0xc151655c}, 2401 {'l', 0x4226b61e, 0xc27df5b1}, 2402 {'@', 0x00000035, 0x00005773},/* 5 x-advance: 87.449219 */ 2403 {'M', 0x416d50c0, 0xc2c86716}, 2404 {'l', 0x4254e2ca, 0x00000000}, 2405 {'4', 0x005b0000, 0x0000feba}, 2406 {'l', 0x00000000, 0x41c48294}, 2407 {'8', 0xf52ff817, 0xfc2ffc17}, 2408 {'q', 0x41863a6a, 0x00000000}, 2409 {0, 0x41d49e10, 0x41131d34}, 2410 {'q', 0x411cc750, 0x41131d34}, 2411 {0, 0x411cc750, 0x41c731d2}, 2412 {'q', 0x00000000, 0x4181655f}, 2413 {0, 0xc12112e8, 0x41c957a0}, 2414 {'q', 0xc12112e4, 0x410ed19d}, 2415 {0, 0xc1e31d34, 0x410ed19d}, 2416 {'8', 0xf89900ce, 0xe795f8cc}, 2417 {'l', 0x00000000, 0xc159fc90}, 2418 {'8', 0x27631a30, 0x0c6c0c33}, 2419 {'q', 0x4139c598, 0x00000000}, 2420 {0, 0x41931d36, 0xc0c36fae}, 2421 {'q', 0x40d8e9a8, 0xc0c36fae}, 2422 {0, 0x40d8e9a8, 0xc1849e12}, 2423 {'q', 0x00000000, 0xc1278448}, 2424 {0, 0xc0d8e9a8, 0xc1849e10}, 2425 {'q', 0xc0d8e9a8, 0xc0c36fb0}, 2426 {0, 0xc1931d36, 0xc0c36fb0}, 2427 {'8', 0x09aa00d5, 0x1ea809d6}, 2428 {'l', 0x00000000, 0xc249579f}, 2429 {'@', 0x00000036, 0x00005773},/* 6 x-advance: 87.449219 */ 2430 {'M', 0x423579fc, 0xc25e036f}, 2431 {'q', 0xc1120a4c, 0x00000000}, 2432 {0, 0xc167f240, 0x40c7bb40}, 2433 {'q', 0xc0a9aa18, 0x40c7bb48}, 2434 {0, 0xc0a9aa18, 0x4188e9aa}, 2435 {'q', 0x00000000, 0x412ce2cc}, 2436 {0, 0x40a9aa18, 0x4188e9aa}, 2437 {'q', 0x40abcfe8, 0x40c7bb48}, 2438 {0, 0x4167f240, 0x40c7bb48}, 2439 {'q', 0x41120a50, 0x00000000}, 2440 {0, 0x4166df5c, 0xc0c7bb46}, 2441 {'q', 0x40abcfe8, 0xc0c9e112}, 2442 {0, 0x40abcfe8, 0xc188e9aa}, 2443 {'q', 0x00000000, 0xc12df5b0}, 2444 {0, 0xc0abcfe8, 0xc188e9aa}, 2445 {'9', 0xffcfffd6, 0xffcfff8d}, 2446 {'m', 0x41d74d50, 0xc229eed1}, 2447 {'l', 0x00000000, 0x41459578}, 2448 {'8', 0xe3aeedd8, 0xf6aef6d7}, 2449 {'q', 0xc156c3e0, 0x00000000}, 2450 {0, 0xc1a44b99, 0x4110f768}, 2451 {'q', 0xc0e180dc, 0x4110f768}, 2452 {0, 0xc100dbec, 0x41db0f78}, 2453 {'8', 0xb94fd21f, 0xe769e72f}, 2454 {'q', 0x41719c58, 0x00000000}, 2455 {0, 0x41be9aa2, 0x41131d34}, 2456 {'q', 0x410cabd0, 0x41120a50}, 2457 {0, 0x410cabd0, 0x41c731d2}, 2458 {'q', 0x00000000, 0x4176fada}, 2459 {0, 0xc1120a50, 0x41c61eee}, 2460 {'q', 0xc1120a50, 0x41154301}, 2461 {0, 0xc1c25cc8, 0x41154301}, 2462 {'q', 0xc18b0f76, 0xb4c00000}, 2463 {0, 0xc1d49e10, 0xc1549e11}, 2464 {'q', 0xc1131d36, 0xc155b0f8}, 2465 {0, 0xc1131d36, 0xc21aa181}, 2466 {'q', 0x00000000, 0xc1be112c}, 2467 {0, 0x41346716, 0xc21768ce}, 2468 {'q', 0x41346718, 0xc16293c0}, 2469 {0, 0x41f225cc, 0xc16293c0}, 2470 {'8', 0x08520028, 0x18560829}, 2471 {'@', 0x00000037, 0x00005773},/* 7 x-advance: 87.449219 */ 2472 {'M', 0x41346716, 0xc2c86716}, 2473 {'l', 0x4280dbeb, 0x00000000}, 2474 {'l', 0x00000000, 0x40b8b2b0}, 2475 {'l', 0xc21180dc, 0x42bcdbeb}, 2476 {'l', 0xc16293c2, 0x00000000}, 2477 {'l', 0x4208e9aa, 0xc2b1957a}, 2478 {'l', 0xc2407bb4, 0x00000000}, 2479 {'l', 0xb6000000, 0xc1368ce0}, 2480 {'@', 0x00000038, 0x00005773},/* 8 x-advance: 87.449219 */ 2481 {'M', 0x422ec3dd, 0xc23e55e8}, 2482 {'q', 0xc11aa180, 0x00000000}, 2483 {0, 0xc173c224, 0x40a55e80}, 2484 {'q', 0xc0b01b7c, 0x40a55e80}, 2485 {0, 0xc0b01b7c, 0x4163a6a8}, 2486 {'q', 0x00000000, 0x4110f76a}, 2487 {0, 0x40b01b7c, 0x4163a6a9}, 2488 {'q', 0x40b24148, 0x40a55e7e}, 2489 {0, 0x4173c224, 0x40a55e7e}, 2490 {'q', 0x411aa184, 0x00000000}, 2491 {0, 0x4173c228, 0xc0a55e7e}, 2492 {'q', 0x40b24148, 0xc0a7844a}, 2493 {0, 0x40b24148, 0xc163a6a9}, 2494 {'q', 0x00000000, 0xc110f768}, 2495 {0, 0xc0b24148, 0xc163a6a8}, 2496 {'9', 0xffd7ffd4, 0xffd7ff87}, 2497 {'m', 0xc158e9a8, 0xc0b8b2b0}, 2498 {'q', 0xc10b98ea, 0xc0097310}, 2499 {0, 0xc159fc90, 0xc101eed0}, 2500 {'q', 0xc09aa182, 0xc0bf2410}, 2501 {0, 0xc09aa182, 0xc1690528}, 2502 {'q', 0x00000000, 0xc14036f8}, 2503 {0, 0x41086037, 0xc197f240}, 2504 {'q', 0x4109731e, 0xc0df5b10}, 2505 {0, 0x41bbeb61, 0xc0df5b10}, 2506 {'q', 0x416f7690, 0x00000000}, 2507 {0, 0x41bbeb62, 0x40df5b10}, 2508 {'q', 0x41086038, 0x40df5b10}, 2509 {0, 0x41086038, 0x4197f240}, 2510 {'q', 0x00000000, 0x41097320}, 2511 {0, 0xc09cc750, 0x41690528}, 2512 {'q', 0xc09aa180, 0x40bf2418}, 2513 {0, 0xc157d6c4, 0x4101eed0}, 2514 {'q', 0x411cc74c, 0x40120a50}, 2515 {0, 0x4173c224, 0x410ed1a0}, 2516 {'q', 0x40b01b80, 0x40d49e10}, 2517 {0, 0x40b01b80, 0x4181eed0}, 2518 {'q', 0x00000000, 0x41690528}, 2519 {0, 0xc10ed198, 0x41b2cabd}, 2520 {'q', 0xc10dbeb8, 0x40f920a5}, 2521 {0, 0xc1cb7d6e, 0x40f920a5}, 2522 {'q', 0xc1849e10, 0x34000000}, 2523 {0, 0xc1cc06de, 0xc0f920a4}, 2524 {'q', 0xc10dbeb7, 0xc0f920a5}, 2525 {0, 0xc10dbeb7, 0xc1b2cabd}, 2526 {'q', 0x00000000, 0xc1198e98}, 2527 {0, 0x40b01b7e, 0xc181eed0}, 2528 {'9', 0xffcb002c, 0xffb9007a}, 2529 {'m', 0xc09eed1c, 0xc1ab4670}, 2530 {'8', 0x61263e00, 0x226d2227}, 2531 {'8', 0xde6c0045, 0x9f27de27}, 2532 {'8', 0x9fd9c200, 0xde94ded9}, 2533 {'8', 0x229300ba, 0x61da22da}, 2534 {'@', 0x00000039, 0x00005773},/* 9 x-advance: 87.449219 */ 2535 {'M', 0x41719c59, 0xc0052784}, 2536 {'l', 0x00000000, 0xc145957a}, 2537 {'8', 0x1d521328, 0x0a520a29}, 2538 {'q', 0x4156c3dc, 0x00000000}, 2539 {0, 0x41a3c226, 0xc10fe482}, 2540 {'q', 0x40e3a6a8, 0xc110f768}, 2541 {0, 0x4101eed4, 0xc1db98ea}, 2542 {'8', 0x46b22ee1, 0x189718d1}, 2543 {'q', 0xc1708974, 0x00000000}, 2544 {0, 0xc1be9aa2, 0xc110f768}, 2545 {'q', 0xc10b98e9, 0xc1120a50}, 2546 {0, 0xc10b98e9, 0xc1c731d4}, 2547 {'q', 0x00000000, 0xc176fad8}, 2548 {0, 0x41120a4f, 0xc1c61eec}, 2549 {'q', 0x41120a4e, 0xc1154300}, 2550 {0, 0x41c25cc7, 0xc1154300}, 2551 {'q', 0x418b0f76, 0x00000000}, 2552 {0, 0x41d4149c, 0x4155b0f8}, 2553 {'q', 0x41131d38, 0x41549e10}, 2554 {0, 0x41131d38, 0x421aa180}, 2555 {'q', 0x00000000, 0x41bd87bc}, 2556 {0, 0xc1346718, 0x421768ce}, 2557 {'q', 0xc133542c, 0x416180dd}, 2558 {0, 0xc1f19c58, 0x416180dd}, 2559 {'8', 0xf8ae00d8, 0xe8aaf8d7}, 2560 {'m', 0x41d7d6c4, 0xc229eed2}, 2561 {'q', 0x41120a50, 0x00000000}, 2562 {0, 0x4166df5c, 0xc0c7bb40}, 2563 {'q', 0x40abcfe0, 0xc0c7bb48}, 2564 {0, 0x40abcfe0, 0xc188e9ac}, 2565 {'q', 0x00000000, 0xc12ce2c8}, 2566 {0, 0xc0abcfe0, 0xc1886034}, 2567 {'q', 0xc0a9aa18, 0xc0c9e120}, 2568 {0, 0xc166df5c, 0xc0c9e120}, 2569 {'q', 0xc1120a50, 0x00000000}, 2570 {0, 0xc167f240, 0x40c9e120}, 2571 {'q', 0xc0a9aa18, 0x40c7bb40}, 2572 {0, 0xc0a9aa18, 0x41886034}, 2573 {'q', 0x00000000, 0x412df5b4}, 2574 {0, 0x40a9aa18, 0x4188e9ac}, 2575 {'q', 0x40abcfe0, 0x40c7bb40}, 2576 {0, 0x4167f240, 0x40c7bb40}, 2577 {'@', 0x0000003a, 0x00002e4f},/* : x-advance: 46.308594 */ 2578 {'M', 0x4180dbeb, 0xc1886037}, 2579 {'l', 0x416293c2, 0x00000000}, 2580 {'4', 0x00880000, 0x0000ff8f}, 2581 {'6', 0xff780000, 0xfe500000}, 2582 {'l', 0x416293c2, 0x00000000}, 2583 {'l', 0x00000000, 0x41886036}, 2584 {'l', 0xc16293c2, 0x00000000}, 2585 {'l', 0x00000000, 0xc1886036}, 2586 {'@', 0x0000003b, 0x00002e4f},/* ; x-advance: 46.308594 */ 2587 {'M', 0x4180dbeb, 0xc28e25cc}, 2588 {'l', 0x416293c2, 0x00000000}, 2589 {'4', 0x00880000, 0x0000ff8f}, 2590 {'6', 0xff780000, 0x01b00000}, 2591 {'l', 0x416293c2, 0x36000000}, 2592 {'l', 0x00000000, 0x4138b2b0}, 2593 {'l', 0xc1301b7c, 0x41abcfe4}, 2594 {'l', 0xc10a8604, 0x00000000}, 2595 {'l', 0x40b01b7c, 0xc1abcfe4}, 2596 {'l', 0x00000000, 0xc138b2b0}, 2597 {'@', 0x0000003c, 0x0000732a},/* < x-advance: 115.164062 */ 2598 {'M', 0x42c93543, 0xc2874d51}, 2599 {'l', 0xc28a8604, 0x41c50c08}, 2600 {'l', 0x428a8604, 0x41c3f921}, 2601 {'l', 0x00000000, 0x41436fac}, 2602 {'l', 0xc2ac149e, 0xc1f9aa17}, 2603 {'l', 0xb5800000, 0xc132414c}, 2604 {'l', 0x42ac149e, 0xc1f9aa16}, 2605 {'l', 0x00000000, 0x41436fa8}, 2606 {'@', 0x0000003d, 0x0000732a},/* = x-advance: 115.164062 */ 2607 {'M', 0x41690527, 0xc279aa18}, 2608 {'l', 0x42ac149e, 0x00000000}, 2609 {'4', 0x005a0000, 0x0000fd50}, 2610 {'6', 0xffa60000, 0x00db0000}, 2611 {'l', 0x42ac149e, 0x00000000}, 2612 {'l', 0x00000000, 0x41368ce4}, 2613 {'l', 0xc2ac149e, 0x00000000}, 2614 {'l', 0xb5800000, 0xc1368ce4}, 2615 {'@', 0x0000003e, 0x0000732a},/* > x-advance: 115.164062 */ 2616 {'M', 0x41690527, 0xc2874d51}, 2617 {'l', 0x00000000, 0xc1436fa8}, 2618 {'l', 0x42ac149e, 0x41f9aa16}, 2619 {'l', 0x00000000, 0x4132414c}, 2620 {'l', 0xc2ac149e, 0x41f9aa17}, 2621 {'l', 0xb5800000, 0xc1436fac}, 2622 {'l', 0x428a414a, 0xc1c3f921}, 2623 {'l', 0xc28a414a, 0xc1c50c08}, 2624 {'@', 0x0000003f, 0x000048f3},/* ? x-advance: 72.949219 */ 2625 {'M', 0x41d1eed1, 0xc1886037}, 2626 {'l', 0x4159fc92, 0x00000000}, 2627 {'4', 0x00880000, 0x0000ff94}, 2628 {'6', 0xff780000, 0xffb20069}, 2629 {'4', 0x0000ff9a, 0xffae0000}, 2630 {'8', 0xa70fca00, 0xaf3fde0f}, 2631 {'l', 0x40c149e0, 0xc0bf2418}, 2632 {'8', 0xcb2ce41e, 0xcd0de70d}, 2633 {'8', 0xb3ddd100, 0xe3a4e3de}, 2634 {'8', 0x12a600d6, 0x369d12d1}, 2635 {'l', 0x00000000, 0xc149e110}, 2636 {'8', 0xd366e232, 0xf16bf134}, 2637 {'q', 0x41459578, 0x00000000}, 2638 {0, 0x419e63a6, 0x40d05270}, 2639 {'q', 0x40f08970, 0x40d05280}, 2640 {0, 0x40f08970, 0x41897320}, 2641 {'8', 0x4ded2800, 0x52bd24ed}, 2642 {'l', 0xc0bcfe48, 0x40b8b2b0}, 2643 {'8', 0x27dd19e7, 0x1bf20df6}, 2644 {'8', 0x1bfc0bfd, 0x2cff10ff}, 2645 {'l', 0x00000000, 0x410414a0}, 2646 {'@', 0x00000040, 0x00008973},/* @ x-advance: 137.449219 */ 2647 {'M', 0x424c9052, 0xc210293c}, 2648 {'q', 0x00000000, 0x41198e9a}, 2649 {0, 0x40987bb8, 0x41719c5a}, 2650 {'8', 0x2b682b26, 0xd4670042}, 2651 {'q', 0x40987bc0, 0xc0b01b80}, 2652 {0, 0x40987bc0, 0xc1708974}, 2653 {'q', 0x00000000, 0xc11655e8}, 2654 {0, 0xc09aa180, 0xc16e63a4}, 2655 {'8', 0xd498d4da, 0x2c9900c0}, 2656 {'9', 0x002cffda, 0x0077ffda}, 2657 {'m', 0x42124f08, 0x41a08973}, 2658 {'8', 0x3db629e0, 0x13a013d7}, 2659 {'q', 0xc138b2b0, 0x00000000}, 2660 {0, 0xc19655e8, 0xc1052784}, 2661 {'q', 0xc0e5cc78, 0xc1063a6a}, 2662 {0, 0xc0e5cc78, 0xc1ae7f24}, 2663 {'q', 0x00000000, 0xc156c3dc}, 2664 {0, 0x40e7f240, 0xc1ae7f24}, 2665 {'q', 0x40e7f240, 0xc1063a68}, 2666 {0, 0x4195cc76, 0xc1063a68}, 2667 {'8', 0x14610037, 0x3c491329}, 2668 {'4', 0xffba0000, 0x0000004c}, 2669 {'l', 0x00000000, 0x4245957a}, 2670 {'q', 0x411cc748, 0xbfbcfe40}, 2671 {0, 0x4174d508, 0xc10ed19a}, 2672 {'q', 0x40b24150, 0xc0f08974}, 2673 {0, 0x40b24150, 0xc19b2af3}, 2674 {'8', 0x95efc700, 0xa3cdcef0}, 2675 {'q', 0xc0df5b10, 0xc10cabd0}, 2676 {0, 0xc1886038, 0xc156c3e0}, 2677 {'q', 0xc1200000, 0xc09655e0}, 2678 {0, 0xc1ae7f24, 0xc09655e0}, 2679 {'q', 0xc104149c, 0x00000000}, 2680 {0, 0xc17d6c3c, 0x400dbea0}, 2681 {'q', 0xc0f2af40, 0x40097320}, 2682 {0, 0xc1606df4, 0x40ce2cb0}, 2683 {'q', 0xc1289734, 0x40db0f80}, 2684 {0, 0xc184149f, 0x418fe482}, 2685 {'q', 0xc0bcfe48, 0x41312e64}, 2686 {0, 0xc0bcfe48, 0x41c036fc}, 2687 {'q', 0x00000000, 0x412abcfc}, 2688 {0, 0x4074d510, 0x419fffff}, 2689 {'q', 0x407920a0, 0x41154302}, 2690 {0, 0x4133542e, 0x41838b2b}, 2691 {'q', 0x40e180e0, 0x40df5b0f}, 2692 {0, 0x41827846, 0x412abcfe}, 2693 {'q', 0x41143018, 0x4067f240}, 2694 {0, 0x419e63a6, 0x4067f240}, 2695 {'q', 0x410a8600, 0x00000000}, 2696 {0, 0x4187d6c4, 0xc038b2ac}, 2697 {'9', 0xffe90043, 0xffbd007a}, 2698 {'l', 0x40c149e0, 0x40ee63a6}, 2699 {'q', 0xc1063a68, 0x40d0527a}, 2700 {0, 0xc19293c0, 0x41200001}, 2701 {'q', 0xc11dda38, 0x405b0f70}, 2702 {0, 0xc1a08974, 0x405b0f70}, 2703 {'q', 0xc146a860, 0x00000000}, 2704 {0, 0xc1bb61ee, 0xc08b98e8}, 2705 {'q', 0xc1301b80, 0xc08dbeb6}, 2706 {0, 0xc19cc74e, 0xc14d19c6}, 2707 {'q', 0xc109731e, 0xc1063a6a}, 2708 {0, 0xc151655e, 0xc19b2af4}, 2709 {'q', 0xc08fe482, 0xc1312e62}, 2710 {0, 0xc08fe482, 0xc1be112d}, 2711 {'q', 0x00000000, 0xc1436fb0}, 2712 {0, 0x40920a4e, 0xc1ba4f08}, 2713 {'q', 0x40920a50, 0xc1312e64}, 2714 {0, 0x41505278, 0xc19bb466}, 2715 {'q', 0x410a8604, 0xc1086038}, 2716 {0, 0x41a00000, 0xc1505278}, 2717 {'q', 0x413579fc, 0xc0920a50}, 2718 {0, 0x41c036fc, 0xc0920a50}, 2719 {'q', 0x4163a6a8, 0x00000000}, 2720 {0, 0x41d301b4, 0x40bad870}, 2721 {'q', 0x41436fb0, 0x40bad880}, 2722 {0, 0x41a3c228, 0x41849e14}, 2723 {'q', 0x40a112e0, 0x40d27840}, 2724 {0, 0x40f4d510, 0x4164b98c}, 2725 {'q', 0x402bcfe0, 0x40f6fad8}, 2726 {0, 0x402bcfe0, 0x417f9208}, 2727 {'q', 0x00000000, 0x418d3543}, 2728 {0, 0xc12abd00, 0x41ded19d}, 2729 {'q', 0xc12abd00, 0x412338b2}, 2730 {0, 0xc1ebb468, 0x4129aa17}, 2731 {'l', 0x00000000, 0xc1255e7f}, 2732 {'@', 0x00000041, 0x00005e06},/* A x-advance: 94.023438 */ 2733 {'M', 0x423beb62, 0xc2adb0f7}, 2734 {'4', 0x018eff6d, 0x00000126}, 2735 {'6', 0xfe72ff6d, 0xff96ffc3}, 2736 {'l', 0x4175e7f4, 0x00000000}, 2737 {'l', 0x4218c06d, 0x42c86716}, 2738 {'l', 0xc16180d8, 0x00000000}, 2739 {'l', 0xc1120a50, 0xc1cda338}, 2740 {'l', 0xc234abd0, 0x00000000}, 2741 {'l', 0xc1120a4e, 0x41cda338}, 2742 {'l', 0xc164b98e, 0x00000000}, 2743 {'l', 0x42190527, 0xc2c86716}, 2744 {'[', 0x00410041, 0x000003d3}, 2745 {'@', 0x00000042, 0x00005e4b},/* B x-advance: 94.292969 */ 2746 {'M', 0x41d86037, 0xc23f68ce}, 2747 {'4', 0x01250000, 0x000000ad}, 2748 {'q', 0x412f0894, 0x00000000}, 2749 {0, 0x4181655c, 0xc08fe482}, 2750 {'8', 0x912adc2a, 0x92d6b500}, 2751 {'9', 0xffddffd7, 0xffddff7f}, 2752 {'6', 0x0000ff53, 0xfeb70000}, 2753 {'4', 0x00f10000, 0x000000a0}, 2754 {'q', 0x411eed18, 0x00000000}, 2755 {0, 0x416c3dd8, 0xc06c3de0}, 2756 {'8', 0xa527e227, 0xa6d9c400}, 2757 {'9', 0xffe2ffda, 0xffe2ff8a}, 2758 {'6', 0x0000ff60, 0xffa7ff94}, 2759 {'l', 0x420a8603, 0x00000000}, 2760 {'q', 0x41780dc0, 0x00000000}, 2761 {0, 0x41bf2414, 0x40ce2cb0}, 2762 {'q', 0x41063a68, 0x40ce2ca0}, 2763 {0, 0x41063a68, 0x419293c0}, 2764 {'q', 0x00000000, 0x41131d38}, 2765 {0, 0xc0897310, 0x416a1810}, 2766 {'q', 0xc0897320, 0x40adf5b0}, 2767 {0, 0xc149e114, 0x40d8e9a8}, 2768 {'q', 0x411ffffc, 0x40097320}, 2769 {0, 0x41780dbc, 0x410fe480}, 2770 {'q', 0x40b24150, 0x40d8e9b0}, 2771 {0, 0x40b24150, 0x4187d6c5}, 2772 {'q', 0x00000000, 0x4156c3dd}, 2773 {0, 0xc1120a50, 0x41a5e7f2}, 2774 {'9', 0x003affb7, 0x003aff31}, 2775 {'l', 0xc20fe482, 0x00000000}, 2776 {'l', 0x00000000, 0xc2c86716}, 2777 {'@', 0x00000043, 0x00005ff9},/* C x-advance: 95.972656 */ 2778 {'M', 0x42b10c07, 0xc2b8f769}, 2779 {'l', 0x00000000, 0x4164b990}, 2780 {'q', 0xc0db0f80, 0xc0cc06e0}, 2781 {0, 0xc16a1810, 0xc1187bb0}, 2782 {'q', 0xc0f6fae0, 0xc049e120}, 2783 {0, 0xc1838b2c, 0xc049e120}, 2784 {'q', 0xc189731c, 0x00000000}, 2785 {0, 0xc1d27843, 0x41289730}, 2786 {'q', 0xc1120a50, 0x41278450}, 2787 {0, 0xc1120a50, 0x41f2af40}, 2788 {'q', 0x00000000, 0x419e63a7}, 2789 {0, 0x41120a50, 0x41f2af40}, 2790 {'q', 0x41120a4e, 0x4127844b}, 2791 {0, 0x41d27843, 0x4127844b}, 2792 {'q', 0x410b98e8, 0x00000000}, 2793 {0, 0x41838b2c, 0xc049e114}, 2794 {'9', 0xffe7003e, 0xffb40075}, 2795 {'l', 0x00000000, 0x416293c2}, 2796 {'q', 0xc0e3a6b0, 0x409aa180}, 2797 {0, 0xc1719c60, 0x40e7f241}, 2798 {'q', 0xc0fd6c30, 0x401aa180}, 2799 {0, 0xc1863a68, 0x401aa180}, 2800 {'q', 0xc1b60370, 0x34000000}, 2801 {0, 0xc20f5b10, 0xc15e4828}, 2802 {'q', 0xc151655c, 0xc15f5b10}, 2803 {0, 0xc151655c, 0xc21836fb}, 2804 {'q', 0x00000000, 0xc1c149e0}, 2805 {0, 0x4151655e, 0xc21836fa}, 2806 {'q', 0x4151655e, 0xc15f5b10}, 2807 {0, 0x420f5b10, 0xc15f5b10}, 2808 {'q', 0x410fe480, 0x00000000}, 2809 {0, 0x41874d50, 0x401aa180}, 2810 {'q', 0x40ff9210, 0x401655e0}, 2811 {0, 0x416f7690, 0x40e3a6a0}, 2812 {'@', 0x00000044, 0x000069d6},/* D x-advance: 105.835938 */ 2813 {'M', 0x41d86037, 0xc2b21eed}, 2814 {'4', 0x026f0000, 0x00000083}, 2815 {'q', 0x41a5e7f2, 0x00000000}, 2816 {0, 0x41f2af3e, 0xc11655e8}, 2817 {'q', 0x411aa180, 0xc11655e8}, 2818 {0, 0x411aa180, 0xc1ed50bf}, 2819 {'q', 0x00000000, 0xc1a112e8}, 2820 {0, 0xc11aa180, 0xc1ebb468}, 2821 {'9', 0xffb5ffb4, 0xffb5ff0e}, 2822 {'6', 0x0000ff7d, 0xffa7ff94}, 2823 {'l', 0x41ded19c, 0x00000000}, 2824 {'q', 0x41e90526, 0x00000000}, 2825 {0, 0x422b01b7, 0x41425cc8}, 2826 {'q', 0x4159fc90, 0x414149e0}, 2827 {0, 0x4159fc90, 0x421768ce}, 2828 {'q', 0x00000000, 0x41cf3f91}, 2829 {0, 0xc15b0f78, 0x421836fa}, 2830 {'9', 0x0061ff93, 0x0061feab}, 2831 {'l', 0xc1ded19c, 0x00000000}, 2832 {'l', 0x00000000, 0xc2c86716}, 2833 {'@', 0x00000045, 0x000056d8},/* E x-advance: 86.843750 */ 2834 {'M', 0x4157d6c4, 0xc2c86716}, 2835 {'l', 0x427d6c3d, 0x00000000}, 2836 {'l', 0x00000000, 0x41368ce0}, 2837 {'l', 0xc24731d2, 0x00000000}, 2838 {'l', 0xb6000000, 0x41ed50c2}, 2839 {'l', 0x423edf5a, 0x00000000}, 2840 {'l', 0x00000000, 0x41368ce0}, 2841 {'l', 0xc23edf5a, 0x00000000}, 2842 {'l', 0xb6000000, 0x42113c22}, 2843 {'l', 0x424c06de, 0x35800000}, 2844 {'l', 0x00000000, 0x41368ce3}, 2845 {'l', 0xc28120a4, 0x00000000}, 2846 {'l', 0xb6800000, 0xc2c86716}, 2847 {'@', 0x00000046, 0x00004f0f},/* F x-advance: 79.058594 */ 2848 {'M', 0x4157d6c4, 0xc2c86716}, 2849 {'l', 0x426655e7, 0x00000000}, 2850 {'l', 0x00000000, 0x41368ce0}, 2851 {'l', 0xc2301b7c, 0x00000000}, 2852 {'l', 0xb6000000, 0x41ec3dda}, 2853 {'l', 0x421eed18, 0x00000000}, 2854 {'l', 0x00000000, 0x41368ce4}, 2855 {'l', 0xc21eed18, 0x00000000}, 2856 {'l', 0xb6000000, 0x423f68ce}, 2857 {'l', 0xc158e9aa, 0x00000000}, 2858 {'l', 0x00000000, 0xc2c86716}, 2859 {'@', 0x00000047, 0x00006a82},/* G x-advance: 106.507812 */ 2860 {'M', 0x42a39fc9, 0xc164b98e}, 2861 {'l', 0x00000000, 0xc1d74d51}, 2862 {'l', 0xc1b12e64, 0x00000000}, 2863 {'4', 0xffa70000, 0x0000011c}, 2864 {'l', 0x00000000, 0x422c149e}, 2865 {'q', 0xc0fb4670, 0x40b24146}, 2866 {0, 0xc18a8600, 0x41074d4f}, 2867 {'q', 0xc11768d0, 0x40346716}, 2868 {0, 0xc1a19c5a, 0x40346716}, 2869 {'q', 0xc1bbeb62, 0x34000000}, 2870 {0, 0xc2131d36, 0xc15b0f76}, 2871 {'q', 0xc1538b28, 0xc15c225c}, 2872 {0, 0xc1538b28, 0xc2190528}, 2873 {'q', 0x00000000, 0xc1c48294}, 2874 {0, 0x41538b2a, 0xc2190526}, 2875 {'q', 0x41549e12, 0xc15c2260}, 2876 {0, 0x42131d36, 0xc15c2260}, 2877 {'q', 0x411cc748, 0x00000000}, 2878 {0, 0x4194b98c, 0x401aa180}, 2879 {'9', 0x00130046, 0x00380082}, 2880 {'l', 0x00000000, 0x4166df60}, 2881 {'q', 0xc0f08970, 0xc0cc06e0}, 2882 {0, 0xc17f9208, 0xc1198e98}, 2883 {'q', 0xc1074d50, 0xc04e2cc0}, 2884 {0, 0xc18e482a, 0xc04e2cc0}, 2885 {'q', 0xc1931d34, 0x00000000}, 2886 {0, 0xc1dd3542, 0x41244b98}, 2887 {'q', 0xc1131d36, 0x41244b98}, 2888 {0, 0xc1131d36, 0x41f4d50c}, 2889 {'q', 0x00000000, 0x41a225cd}, 2890 {0, 0x41131d36, 0x41f44b99}, 2891 {'q', 0x4114301c, 0x41244b99}, 2892 {0, 0x41dd3542, 0x41244b99}, 2893 {'8', 0xf7660039, 0xe151f62d}, 2894 {'@', 0x00000048, 0x0000675b},/* H x-advance: 103.355469 */ 2895 {'M', 0x4157d6c4, 0xc2c86716}, 2896 {'l', 0x4158e9aa, 0x00000000}, 2897 {'l', 0x00000000, 0x42244b99}, 2898 {'l', 0x42450c06, 0x00000000}, 2899 {'l', 0x00000000, 0xc2244b99}, 2900 {'l', 0x4158e9a8, 0x00000000}, 2901 {'l', 0x00000000, 0x42c86716}, 2902 {'l', 0xc158e9a8, 0x00000000}, 2903 {'l', 0x00000000, 0xc23edf5b}, 2904 {'l', 0xc2450c06, 0x00000000}, 2905 {'l', 0xb6000000, 0x423edf5b}, 2906 {'l', 0xc158e9aa, 0x00000000}, 2907 {'l', 0x00000000, 0xc2c86716}, 2908 {'@', 0x00000049, 0x00002889},/* I x-advance: 40.535156 */ 2909 {'M', 0x4157d6c4, 0xc2c86716}, 2910 {'l', 0x4158e9aa, 0x00000000}, 2911 {'l', 0x00000000, 0x42c86716}, 2912 {'l', 0xc158e9aa, 0x00000000}, 2913 {'l', 0x00000000, 0xc2c86716}, 2914 {'@', 0x0000004a, 0x00002889},/* J x-advance: 40.535156 */ 2915 {'M', 0x4157d6c4, 0xc2c86716}, 2916 {'4', 0x0000006c, 0x02e90000}, 2917 {'q', 0x00000000, 0x4190f769}, 2918 {0, 0xc0dd3544, 0x41d27845}, 2919 {'9', 0x0041ffca, 0x0041ff50}, 2920 {'4', 0x0000ffd7, 0xffa50000}, 2921 {'l', 0x40874d50, 0x00000000}, 2922 {'q', 0x410fe482, 0x00000000}, 2923 {0, 0x414af3f9, 0xc0a112e6}, 2924 {'q', 0x406c3ddc, 0xc0a112e5}, 2925 {0, 0x406c3ddc, 0xc1906df5}, 2926 {'l', 0x00000000, 0xc2ba7165}, 2927 {'@', 0x0000004b, 0x00005a22},/* K x-advance: 90.132812 */ 2928 {'M', 0x4157d6c4, 0xc2c86716}, 2929 {'l', 0x4158e9aa, 0x00000000}, 2930 {'l', 0x00000000, 0x4229655e}, 2931 {'l', 0x4233dda2, 0xc229655e}, 2932 {'l', 0x418b98ec, 0x00000000}, 2933 {'l', 0xc246ed1a, 0x423ad87b}, 2934 {'l', 0x42552784, 0x4255f5b1}, 2935 {'l', 0xc18ed19c, 0x00000000}, 2936 {'l', 0xc2407bb4, 0xc2410527}, 2937 {'l', 0xb6000000, 0x42410527}, 2938 {'l', 0xc158e9aa, 0x00000000}, 2939 {'l', 0x00000000, 0xc2c86716}, 2940 {'@', 0x0000004c, 0x00004c93},/* L x-advance: 76.574219 */ 2941 {'M', 0x4157d6c4, 0xc2c86716}, 2942 {'l', 0x4158e9aa, 0x00000000}, 2943 {'l', 0x00000000, 0x42b1957a}, 2944 {'l', 0x42432af4, 0xb6400000}, 2945 {'l', 0x00000000, 0x41368ce3}, 2946 {'l', 0xc279655f, 0x00000000}, 2947 {'l', 0x00000000, 0xc2c86716}, 2948 {'[', 0x0041004c, 0x00000327}, 2949 {'@', 0x0000004d, 0x00007697},/* M x-advance: 118.589844 */ 2950 {'M', 0x4157d6c4, 0xc2c86716}, 2951 {'l', 0x41a19c58, 0x00000000}, 2952 {'l', 0x41cc9054, 0x42886036}, 2953 {'l', 0x41cda336, 0xc2886036}, 2954 {'l', 0x41a19c5c, 0x00000000}, 2955 {'l', 0x00000000, 0x42c86716}, 2956 {'l', 0xc1538b30, 0x00000000}, 2957 {'l', 0x00000000, 0xc2aff920}, 2958 {'l', 0xc1ceb61c, 0x4289731c}, 2959 {'l', 0xc159fc94, 0x36800000}, 2960 {'l', 0xc1ceb61e, 0xc289731c}, 2961 {'l', 0x00000000, 0x42aff920}, 2962 {'l', 0xc1527844, 0x00000000}, 2963 {'l', 0x00000000, 0xc2c86716}, 2964 {'@', 0x0000004e, 0x000066d1},/* N x-advance: 102.816406 */ 2965 {'M', 0x4157d6c4, 0xc2c86716}, 2966 {'l', 0x41920a4f, 0x00000000}, 2967 {'l', 0x4231b7d6, 0x42a7a6a8}, 2968 {'l', 0x00000000, 0xc2a7a6a8}, 2969 {'l', 0x41527848, 0x00000000}, 2970 {'l', 0x00000000, 0x42c86716}, 2971 {'l', 0xc1920a50, 0x00000000}, 2972 {'l', 0xc231b7d6, 0xc2a7a6a8}, 2973 {'l', 0x00000000, 0x42a7a6a8}, 2974 {'l', 0xc1527844, 0x00000000}, 2975 {'l', 0x00000000, 0xc2c86716}, 2976 {'@', 0x0000004f, 0x00006c30},/* O x-advance: 108.187500 */ 2977 {'M', 0x4258a4f0, 0xc2b6036f}, 2978 {'q', 0xc16c3dd8, 0x00000000}, 2979 {0, 0xc1bbeb61, 0x41301b78}, 2980 {'q', 0xc10a8604, 0x41301b80}, 2981 {0, 0xc10a8604, 0x41f00000}, 2982 {'q', 0x00000000, 0x419768cf}, 2983 {0, 0x410a8604, 0x41ef768d}, 2984 {'q', 0x410b98ea, 0x41301b7d}, 2985 {0, 0x41bbeb61, 0x41301b7d}, 2986 {'q', 0x416c3dd8, 0x00000000}, 2987 {0, 0x41bad87c, 0xc1301b7d}, 2988 {'q', 0x410a8600, 0xc1301b7c}, 2989 {0, 0x410a8600, 0xc1ef768d}, 2990 {'q', 0x00000000, 0xc197f240}, 2991 {0, 0xc10a8600, 0xc1f00000}, 2992 {'9', 0xffa8ffbc, 0xffa8ff46}, 2993 {'m', 0x00000000, 0xc1301b80}, 2994 {'q', 0x41a89730, 0x00000000}, 2995 {0, 0x4206c3de, 0x416293c0}, 2996 {'q', 0x4149e110, 0x416180e0}, 2997 {0, 0x4149e110, 0x421768ce}, 2998 {'q', 0x00000000, 0x41bd87bc}, 2999 {0, 0xc149e110, 0x421768ce}, 3000 {'q', 0xc149e118, 0x416180dd}, 3001 {0, 0xc206c3de, 0x416180dd}, 3002 {'q', 0xc1a920a4, 0xb4c00000}, 3003 {0, 0xc2074d50, 0xc16180dc}, 3004 {'q', 0xc149e114, 0xc16180db}, 3005 {0, 0xc149e114, 0xc21768ce}, 3006 {'q', 0x00000000, 0xc1be112c}, 3007 {0, 0x4149e112, 0xc21768ce}, 3008 {'q', 0x414af3fa, 0xc16293c0}, 3009 {0, 0x42074d50, 0xc16293c0}, 3010 {'[', 0x002d004f, 0x000003d3}, 3011 {'@', 0x00000050, 0x000052e2},/* P x-advance: 82.882812 */ 3012 {'M', 0x41d86037, 0xc2b21eed}, 3013 {'4', 0x012d0000, 0x00000088}, 3014 {'q', 0x411768cc, 0x00000000}, 3015 {0, 0x416a180c, 0xc09cc750}, 3016 {'8', 0x9129d929, 0x91d7b900}, 3017 {'9', 0xffd9ffd7, 0xffd9ff8b}, 3018 {'6', 0x0000ff78, 0xffa7ff94}, 3019 {'l', 0x41f4d50c, 0x00000000}, 3020 {'q', 0x4186c3dc, 0x00000000}, 3021 {0, 0x41cb7d6a, 0x40f4d510}, 3022 {'q', 0x410a8608, 0x40f2af40}, 3023 {0, 0x410a8608, 0x41b24148}, 3024 {'q', 0x00000000, 0x416d50c0}, 3025 {0, 0xc10a8608, 0x41b35430}, 3026 {'9', 0x003cffbc, 0x003cff35}, 3027 {'l', 0xc1886037, 0x00000000}, 3028 {'l', 0x00000000, 0x422112e6}, 3029 {'l', 0xc158e9aa, 0x00000000}, 3030 {'l', 0x00000000, 0xc2c86716}, 3031 {'@', 0x00000051, 0x00006c30},/* Q x-advance: 108.187500 */ 3032 {'M', 0x4258a4f0, 0xc2b6036f}, 3033 {'q', 0xc16c3dd8, 0x00000000}, 3034 {0, 0xc1bbeb61, 0x41301b78}, 3035 {'q', 0xc10a8604, 0x41301b80}, 3036 {0, 0xc10a8604, 0x41f00000}, 3037 {'q', 0x00000000, 0x419768cf}, 3038 {0, 0x410a8604, 0x41ef768d}, 3039 {'q', 0x410b98ea, 0x41301b7d}, 3040 {0, 0x41bbeb61, 0x41301b7d}, 3041 {'q', 0x416c3dd8, 0x00000000}, 3042 {0, 0x41bad87c, 0xc1301b7d}, 3043 {'q', 0x410a8600, 0xc1301b7c}, 3044 {0, 0x410a8600, 0xc1ef768d}, 3045 {'q', 0x00000000, 0xc197f240}, 3046 {0, 0xc10a8600, 0xc1f00000}, 3047 {'9', 0xffa8ffbc, 0xffa8ff46}, 3048 {'m', 0x4197f240, 0x42b263a6}, 3049 {'4', 0x009c008e, 0x0000ff7d}, 3050 {'l', 0xc16d50bc, 0xc1805278}, 3051 {'8', 0x01e501ef, 0x00ef00f7}, 3052 {'q', 0xc1a920a4, 0x00000000}, 3053 {0, 0xc2074d50, 0xc16180dc}, 3054 {'q', 0xc149e114, 0xc16293c1}, 3055 {0, 0xc149e114, 0xc21768ce}, 3056 {'q', 0x00000000, 0xc1be112c}, 3057 {0, 0x4149e112, 0xc21768ce}, 3058 {'q', 0x414af3fa, 0xc16293c0}, 3059 {0, 0x42074d50, 0xc16293c0}, 3060 {'q', 0x41a89730, 0x00000000}, 3061 {0, 0x4206c3de, 0x416293c0}, 3062 {'q', 0x4149e110, 0x416180e0}, 3063 {0, 0x4149e110, 0x421768ce}, 3064 {'q', 0x00000000, 0x418b98ea}, 3065 {0, 0xc0e180e0, 0x41eeed1a}, 3066 {'q', 0xc0df5b10, 0x4146a860}, 3067 {0, 0xc1a225cc, 0x419293c2}, 3068 {'[', 0x002d0051, 0x000003d3}, 3069 {'@', 0x00000052, 0x00005f80},/* R x-advance: 95.500000 */ 3070 {'M', 0x427406df, 0xc23beb62}, 3071 {'8', 0x32430b22, 0x6a422621}, 3072 {'4', 0x00db006e, 0x0000ff8c}, 3073 {'l', 0xc14d19c8, 0xc1cda338}, 3074 {'8', 0x96b3b0d9, 0xe69be6db}, 3075 {'l', 0xc16c3dda, 0x00000000}, 3076 {'l', 0x00000000, 0x4229655e}, 3077 {'4', 0x0000ff94, 0xfcdf0000}, 3078 {'l', 0x41f4d50c, 0x00000000}, 3079 {'q', 0x4189731c, 0x00000000}, 3080 {0, 0x41cd19c6, 0x40e5cc70}, 3081 {'q', 0x41074d50, 0x40e5cc80}, 3082 {0, 0x41074d50, 0x41ad6c40}, 3083 {'q', 0x00000000, 0x411768cc}, 3084 {0, 0xc08dbec0, 0x417b4670}, 3085 {'9', 0x0031ffde, 0x0045ff9a}, 3086 {'m', 0xc207d6c4, 0xc2285278}, 3087 {'4', 0x011c0000, 0x00000088}, 3088 {'q', 0x411cc74c, 0x00000000}, 3089 {0, 0x416c3dd8, 0xc08fe480}, 3090 {'8', 0x9628dc28, 0x97d8ba00}, 3091 {'q', 0xc09eed18, 0xc08fe480}, 3092 {0, 0xc16c3dd8, 0xc08fe480}, 3093 {'l', 0xc1886037, 0x00000000}, 3094 {'@', 0x00000053, 0x0000573f},/* S x-advance: 87.246094 */ 3095 {'M', 0x42931d35, 0xc2c1d354}, 3096 {'l', 0x00000000, 0x41538b28}, 3097 {'q', 0xc0f6fad0, 0xc06c3dc0}, 3098 {0, 0xc1690528, 0xc0b01b70}, 3099 {'q', 0xc0db0f70, 0xbfe7f240}, 3100 {0, 0xc1538b28, 0xbfe7f240}, 3101 {'q', 0xc1312e64, 0x00000000}, 3102 {0, 0xc188e9ab, 0x40897310}, 3103 {'8', 0x61d122d1, 0x501f3500}, 3104 {'9', 0x001a0020, 0x002b0079}, 3105 {'l', 0x410301b8, 0x3fd6c3e0}, 3106 {'q', 0x4172af40, 0x4038b2b0}, 3107 {0, 0x41b2cabc, 0x412338b0}, 3108 {'q', 0x40e7f240, 0x40e7f240}, 3109 {0, 0x40e7f240, 0x419bb467}, 3110 {'q', 0x00000000, 0x41690528}, 3111 {0, 0xc11cc750, 0x41b0a4f0}, 3112 {'q', 0xc11bb464, 0x40f08975}, 3113 {0, 0xc1e4b98c, 0x40f08975}, 3114 {'q', 0xc0e3a6a8, 0x34000000}, 3115 {0, 0xc172af40, 0xbfce2cab}, 3116 {'9', 0xfff4ffc1, 0xffdaff7c}, 3117 {'l', 0x00000000, 0xc15f5b0f}, 3118 {'q', 0x4104149e, 0x4094301c}, 3119 {0, 0x4181655e, 0x40df5b0e}, 3120 {'q', 0x40fd6c3c, 0x401655e8}, 3121 {0, 0x417920a6, 0x401655e8}, 3122 {'q', 0x4139c594, 0x00000000}, 3123 {0, 0x418f5b0e, 0xc0920a4e}, 3124 {'8', 0x9832dc32, 0xa4dcc500}, 3125 {'9', 0xffdfffdd, 0xffcfff8a}, 3126 {'l', 0xc10414a0, 0xbfce2cc0}, 3127 {'q', 0xc172af3e, 0xc04149e0}, 3128 {0, 0xc1af920a, 0xc11768cc}, 3129 {'q', 0xc0d8e9a6, 0xc0ce2cb0}, 3130 {0, 0xc0d8e9a6, 0xc18f5b0e}, 3131 {'q', 0x00000000, 0xc1549e18}, 3132 {0, 0x41154301, 0xc1a7844c}, 3133 {'q', 0x411655e8, 0xc0f4d510}, 3134 {0, 0x41ceb61f, 0xc0f4d510}, 3135 {'q', 0x40e180d8, 0x00000000}, 3136 {0, 0x4165cc74, 0x3fa338c0}, 3137 {'q', 0x40ea1808, 0x3fa338c0}, 3138 {0, 0x416f768c, 0x4074d500}, 3139 {'[', 0x00410053, 0x0000028c}, 3140 {'@', 0x00000054, 0x000053f5},/* T x-advance: 83.957031 */ 3141 {'M', 0xbece2cac, 0xc2c86716}, 3142 {'l', 0x42a987bb, 0x00000000}, 3143 {'l', 0x00000000, 0x41368ce0}, 3144 {'l', 0xc20e4828, 0x00000000}, 3145 {'l', 0x00000000, 0x42b1957a}, 3146 {'l', 0xc159fc90, 0x00000000}, 3147 {'l', 0x00000000, 0xc2b1957a}, 3148 {'l', 0xc20e4829, 0x00000000}, 3149 {'l', 0xb5b00000, 0xc1368ce0}, 3150 {'@', 0x00000055, 0x0000649a},/* U x-advance: 100.601562 */ 3151 {'M', 0x413f2414, 0xc2c86716}, 3152 {'4', 0x0000006c, 0x01e60000}, 3153 {'q', 0x00000000, 0x4180dbeb}, 3154 {0, 0x40bad87c, 0x41b9c595}, 3155 {'q', 0x40bad87c, 0x40e180da}, 3156 {0, 0x419768cd, 0x40e180da}, 3157 {'q', 0x41505278, 0x00000000}, 3158 {0, 0x4196df5a, 0xc0e180da}, 3159 {'9', 0xffc8002e, 0xff47002e}, 3160 {'4', 0xfe1a0000, 0x0000006c}, 3161 {'l', 0x00000000, 0x427a338b}, 3162 {'q', 0x00000000, 0x419cc74d}, 3163 {0, 0xc11bb468, 0x41ecc74c}, 3164 {'q', 0xc11aa180, 0x41200001}, 3165 {0, 0xc1e4b98e, 0x41200001}, 3166 {'q', 0xc197f240, 0xb4c00000}, 3167 {0, 0xc1e5cc74, 0xc1200000}, 3168 {'q', 0xc11aa180, 0xc11fffff}, 3169 {0, 0xc11aa180, 0xc1ecc74c}, 3170 {'l', 0x00000000, 0xc27a338b}, 3171 {'@', 0x00000056, 0x00005e06},/* V x-advance: 94.023438 */ 3172 {'M', 0x421d50c0, 0x00000000}, 3173 {'l', 0xc2190527, 0xc2c86716}, 3174 {'l', 0x416293c1, 0x00000000}, 3175 {'l', 0x41fdf5b2, 0x42a8b98e}, 3176 {'l', 0x41fe7f24, 0xc2a8b98e}, 3177 {'l', 0x416180d8, 0x00000000}, 3178 {'l', 0xc218c06d, 0x42c86716}, 3179 {'l', 0xc175e7f4, 0x00000000}, 3180 {'@', 0x00000057, 0x000087e7},/* W x-advance: 135.902344 */ 3181 {'M', 0x40920a4f, 0xc2c86716}, 3182 {'l', 0x415b0f76, 0x00000000}, 3183 {'l', 0x41a89731, 0x42a9655e}, 3184 {'l', 0x41a80dbe, 0xc2a9655e}, 3185 {'l', 0x4173c224, 0x00000000}, 3186 {'l', 0x41a89734, 0x42a9655e}, 3187 {'l', 0x41a80dbc, 0xc2a9655e}, 3188 {'l', 0x415c2260, 0x00000000}, 3189 {'l', 0xc1c957a0, 0x42c86716}, 3190 {'l', 0xc1886038, 0x00000000}, 3191 {'l', 0xc1a920a4, 0xc2adf5b1}, 3192 {'l', 0xc1aabcfe, 0x42adf5b1}, 3193 {'l', 0xc1886036, 0x00000000}, 3194 {'l', 0xc1c8ce2c, 0xc2c86716}, 3195 {'@', 0x00000058, 0x00005e29},/* X x-advance: 94.160156 */ 3196 {'M', 0x410a8603, 0xc2c86716}, 3197 {'l', 0x41690527, 0x00000000}, 3198 {'l', 0x41c731d3, 0x4214fe48}, 3199 {'l', 0x41c844b8, 0xc214fe48}, 3200 {'l', 0x41690528, 0x00000000}, 3201 {'l', 0xc200dbeb, 0x42407bb4}, 3202 {'l', 0x4209731d, 0x42505278}, 3203 {'l', 0xc1690528, 0x00000000}, 3204 {'l', 0xc1e180da, 0xc22a7844}, 3205 {'l', 0xc1e31d35, 0x422a7844}, 3206 {'l', 0xc16a180e, 0x00000000}, 3207 {'l', 0x420f1656, 0xc255f5b1}, 3208 {'l', 0xc1f9aa18, 0xc23ad87b}, 3209 {'@', 0x00000059, 0x000053f5},/* Y x-advance: 83.957031 */ 3210 {'M', 0xbe89731d, 0xc2c86716}, 3211 {'l', 0x41690527, 0x00000000}, 3212 {'l', 0x41de4829, 0x4224d50c}, 3213 {'l', 0x41dcabd0, 0xc224d50c}, 3214 {'l', 0x41690528, 0x00000000}, 3215 {'l', 0xc20dbeb6, 0x4251eed1}, 3216 {'l', 0x00000000, 0x423edf5b}, 3217 {'l', 0xc159fc90, 0x00000000}, 3218 {'l', 0x00000000, 0xc23edf5b}, 3219 {'l', 0xc20dbeb6, 0xc251eed1}, 3220 {'@', 0x0000005a, 0x00005e29},/* Z x-advance: 94.160156 */ 3221 {'M', 0x40f6fad8, 0xc2c86716}, 3222 {'l', 0x429d731c, 0x00000000}, 3223 {'l', 0x00000000, 0x41255e80}, 3224 {'l', 0xc27d6c3c, 0x429ce9aa}, 3225 {'l', 0x4281cc74, 0xb6400000}, 3226 {'l', 0x00000000, 0x41368ce3}, 3227 {'l', 0xc2a39fc8, 0x00000000}, 3228 {'l', 0xb6400000, 0xc1255e7f}, 3229 {'l', 0x427d6c3d, 0xc29ce9aa}, 3230 {'l', 0xc2773f91, 0x00000000}, 3231 {'l', 0x00000000, 0xc1368ce0}, 3232 {'@', 0x0000005b, 0x0000359f},/* [ x-advance: 53.621094 */ 3233 {'M', 0x413cfe48, 0xc2d0dbeb}, 3234 {'l', 0x41e3a6a8, 0x00000000}, 3235 {'l', 0x00000000, 0x41198e98}, 3236 {'l', 0xc180dbeb, 0x00000000}, 3237 {'l', 0x00000000, 0x42ceb61f}, 3238 {'l', 0x4180dbeb, 0xb5800000}, 3239 {'l', 0x00000000, 0x41198e9b}, 3240 {'l', 0xc1e3a6a8, 0x00000000}, 3241 {'l', 0x00000000, 0xc2f519c5}, 3242 {'@', 0x0000005c, 0x00002e4f},/* \ x-advance: 46.308594 */ 3243 {'M', 0x41368ce3, 0xc2c86716}, 3244 {'l', 0x420b98e9, 0x42e1e7f2}, 3245 {'l', 0xc1368ce4, 0xb5800000}, 3246 {'l', 0xc20b98e9, 0xc2e1e7f2}, 3247 {'l', 0x41368ce3, 0x00000000}, 3248 {'@', 0x0000005d, 0x0000359f},/* ] x-advance: 53.621094 */ 3249 {'M', 0x42273f92, 0xc2d0dbeb}, 3250 {'l', 0x00000000, 0x42f519c5}, 3251 {'l', 0xc1e3a6a8, 0x36000000}, 3252 {'l', 0xb5800000, 0xc1198e9b}, 3253 {'l', 0x41805278, 0x00000000}, 3254 {'l', 0x00000000, 0xc2ceb61f}, 3255 {'l', 0xc1805278, 0x00000000}, 3256 {'l', 0xb5800000, 0xc1198e98}, 3257 {'l', 0x41e3a6a8, 0x00000000}, 3258 {'@', 0x0000005e, 0x0000732a},/* ^ x-advance: 115.164062 */ 3259 {'M', 0x42805278, 0xc2c86716}, 3260 {'l', 0x4211c596, 0x421587bb}, 3261 {'l', 0xc157d6c8, 0x00000000}, 3262 {'l', 0xc1ec3dd8, 0xc1d4149e}, 3263 {'l', 0xc1ec3ddb, 0x41d4149e}, 3264 {'l', 0xc157d6c3, 0x00000000}, 3265 {'l', 0x4211c595, 0xc21587bb}, 3266 {'l', 0x41527844, 0x00000000}, 3267 {'@', 0x0000005f, 0x000044b9},/* _ x-advance: 68.722656 */ 3268 {'M', 0x428c225d, 0x41b68ce3}, 3269 {'l', 0x00000000, 0x41198e9a}, 3270 {'l', 0xc28ed19d, 0x00000000}, 3271 {'l', 0x36600000, 0xc1198e9a}, 3272 {'l', 0x428ed19d, 0x00000000}, 3273 {'@', 0x00000060, 0x000044b9},/* ` x-advance: 68.722656 */ 3274 {'M', 0x41c50c07, 0xc2dbdda3}, 3275 {'l', 0x419768cd, 0x41c8ce2c}, 3276 {'l', 0xc1244b98, 0x00000000}, 3277 {'l', 0xc1af0896, 0xc1c8ce2c}, 3278 {'l', 0x41538b2a, 0x00000000}, 3279 {'@', 0x00000061, 0x0000543a},/* a x-advance: 84.226562 */ 3280 {'M', 0x423c74d5, 0xc2172414}, 3281 {'q', 0xc16f768c, 0x00000000}, 3282 {0, 0xc1a5e7f2, 0x405b0f70}, 3283 {'8', 0x5dd21bd2, 0x53223400}, 3284 {'q', 0x408b98e8, 0x4074d50c}, 3285 {0, 0x413cfe46, 0x4074d50c}, 3286 {'q', 0x41244b9c, 0x00000000}, 3287 {0, 0x41838b2c, 0xc0e7f242}, 3288 {'9', 0xffc60031, 0xff650031}, 3289 {'4', 0xffea0000, 0x0000ff9e}, 3290 {'m', 0x41c50c06, 0xc0a338b8}, 3291 {'4', 0x01570000, 0x0000ff9e}, 3292 {'l', 0x00000000, 0xc1368ce3}, 3293 {'q', 0xc0874d50, 0x40db0f77}, 3294 {0, 0xc1289734, 0x412225cd}, 3295 {'q', 0xc0c9e110, 0x404e2caa}, 3296 {0, 0xc176fad8, 0x404e2caa}, 3297 {'q', 0xc138b2ae, 0x34000000}, 3298 {0, 0xc1931d34, 0xc0ce2cab}, 3299 {'q', 0xc0d8e9ac, 0xc0d05278}, 3300 {0, 0xc0d8e9ac, 0xc18b0f76}, 3301 {'q', 0x00000000, 0xc14af3fc}, 3302 {0, 0x41074d50, 0xc1990528}, 3303 {'9', 0xffcd0044, 0xffcd00ca}, 3304 {'4', 0x0000008a, 0xfff70000}, 3305 {'q', 0x00000000, 0xc1086034}, 3306 {0, 0xc0b46718, 0xc1527844}, 3307 {'q', 0xc0b24148, 0xc09655e0}, 3308 {0, 0xc17b4670, 0xc09655e0}, 3309 {'8', 0x0c9c00cd, 0x25a30cd0}, 3310 {'l', 0x00000000, 0xc1368ce4}, 3311 {'8', 0xe169ec36, 0xf663f633}, 3312 {'q', 0x41827844, 0x00000000}, 3313 {0, 0x41c2e63a, 0x41074d50}, 3314 {'q', 0x4100dbec, 0x41074d54}, 3315 {0, 0x4100dbec, 0x41cd19c6}, 3316 {'@', 0x00000062, 0x0000573f},/* b x-advance: 87.246094 */ 3317 {'M', 0x4285d354, 0xc216112e}, 3318 {'q', 0x00000000, 0xc159fc90}, 3319 {0, 0xc0b46718, 0xc1aabcfe}, 3320 {'q', 0xc0b24148, 0xc0f920a8}, 3321 {0, 0xc175e7f0, 0xc0f920a8}, 3322 {'q', 0xc11cc750, 0x00000000}, 3323 {0, 0xc176fada, 0x40f920a8}, 3324 {'q', 0xc0b24148, 0x40f6fad8}, 3325 {0, 0xc0b24148, 0x41aabcfe}, 3326 {'q', 0x00000000, 0x4159fc90}, 3327 {0, 0x40b24148, 0x41ab4671}, 3328 {'q', 0x40b46714, 0x40f6fad8}, 3329 {0, 0x4176fada, 0x40f6fad8}, 3330 {'q', 0x411cc74c, 0x00000000}, 3331 {0, 0x4175e7f0, 0xc0f6fad8}, 3332 {'9', 0xffc2002d, 0xff55002d}, 3333 {'m', 0xc2280dbe, 0xc1d1eed2}, 3334 {'q', 0x407920a0, 0xc0d6c3d8}, 3335 {0, 0x411cc74c, 0xc11eed1c}, 3336 {'q', 0x40bf2410, 0xc0527840}, 3337 {0, 0x4163a6a8, 0xc0527840}, 3338 {'q', 0x415b0f74, 0x00000000}, 3339 {0, 0x41b1b7d6, 0x412df5b0}, 3340 {'q', 0x41097320, 0x412df5b4}, 3341 {0, 0x41097320, 0x41e4b990}, 3342 {'q', 0x00000000, 0x418dbeb6}, 3343 {0, 0xc1097320, 0x41e4b98e}, 3344 {'q', 0xc1086038, 0x412df5b1}, 3345 {0, 0xc1b1b7d6, 0x412df5b1}, 3346 {'q', 0xc10414a0, 0xb4c00000}, 3347 {0, 0xc163a6a8, 0xc04e2cad}, 3348 {'9', 0xffe6ffd1, 0xffb0ffb2}, 3349 {'l', 0x00000000, 0x41346716}, 3350 {'l', 0xc146a860, 0x00000000}, 3351 {'l', 0x00000000, 0xc2d0dbeb}, 3352 {'l', 0x4146a860, 0x00000000}, 3353 {'l', 0x00000000, 0x4222af3f}, 3354 {'@', 0x00000063, 0x00004b92},/* c x-advance: 75.570312 */ 3355 {'M', 0x4286180e, 0xc2909052}, 3356 {'l', 0x00000000, 0x4138b2ac}, 3357 {'8', 0xdeace9d7, 0xf5acf5d7}, 3358 {'q', 0xc14036fc, 0x00000000}, 3359 {0, 0xc1954302, 0x40f4d508}, 3360 {'q', 0xc0d49e10, 0x40f2af40}, 3361 {0, 0xc0d49e10, 0x41aabcfe}, 3362 {'q', 0x00000000, 0x415c225c}, 3363 {0, 0x40d49e10, 0x41ab4671}, 3364 {'q', 0x40d49e10, 0x40f2af3e}, 3365 {0, 0x41954302, 0x40f2af3e}, 3366 {'8', 0xf554002a, 0xde54f52a}, 3367 {'l', 0x00000000, 0x41368ce2}, 3368 {'8', 0x1cab13d7, 0x09a309d4}, 3369 {'q', 0xc187d6c4, 0x00000000}, 3370 {0, 0xc1d7d6c4, 0xc12abcfe}, 3371 {'q', 0xc1200000, 0xc12abcff}, 3372 {0, 0xc1200000, 0xc1e655e8}, 3373 {'q', 0xb5000000, 0xc1931d36}, 3374 {0, 0x412112e6, 0xc1e768d0}, 3375 {'q', 0x412225cc, 0xc1289730}, 3376 {0, 0x41ddbeb5, 0xc1289730}, 3377 {'8', 0x0959002d, 0x1b54092b}, 3378 {'@', 0x00000064, 0x0000573f},/* d x-advance: 87.246094 */ 3379 {'M', 0x4279aa18, 0xc27f0897}, 3380 {'l', 0x00000000, 0xc222af3f}, 3381 {'l', 0x41459578, 0x00000000}, 3382 {'4', 0x03430000, 0x0000ff9e}, 3383 {'l', 0x00000000, 0xc1346716}, 3384 {'q', 0xc07920b0, 0x40d6c3dd}, 3385 {0, 0xc11dda34, 0x41200000}, 3386 {'q', 0xc0bcfe48, 0x404e2caa}, 3387 {0, 0xc163a6a8, 0x404e2caa}, 3388 {'q', 0xc159fc90, 0x34000000}, 3389 {0, 0xc1b1b7d7, 0xc12df5b0}, 3390 {'q', 0xc1086036, 0xc12df5b0}, 3391 {0, 0xc1086036, 0xc1e4b98e}, 3392 {'q', 0xb5000000, 0xc18dbeb6}, 3393 {0, 0x41086036, 0xc1e4b990}, 3394 {'q', 0x4109731e, 0xc12df5b0}, 3395 {0, 0x41b1b7d7, 0xc12df5b0}, 3396 {'q', 0x41052784, 0x00000000}, 3397 {0, 0x4163a6a8, 0x40527840}, 3398 {'9', 0x0019002f, 0x004f004e}, 3399 {'m', 0xc2285278, 0x41d1eed2}, 3400 {'q', 0xb6000000, 0x4159fc90}, 3401 {0, 0x40b24148, 0x41ab4671}, 3402 {'q', 0x40b46714, 0x40f6fad8}, 3403 {0, 0x4176fad8, 0x40f6fad8}, 3404 {'q', 0x411cc74c, 0x00000000}, 3405 {0, 0x4176fad8, 0xc0f6fad8}, 3406 {'q', 0x40b46718, 0xc0f920a4}, 3407 {0, 0x40b46718, 0xc1ab4671}, 3408 {'q', 0x00000000, 0xc159fc90}, 3409 {0, 0xc0b46718, 0xc1aabcfe}, 3410 {'q', 0xc0b46718, 0xc0f920a8}, 3411 {0, 0xc176fad8, 0xc0f920a8}, 3412 {'q', 0xc11cc74e, 0x00000000}, 3413 {0, 0xc176fad8, 0x40f920a8}, 3414 {'q', 0xc0b2414c, 0x40f6fad8}, 3415 {0, 0xc0b2414c, 0x41aabcfe}, 3416 {'@', 0x00000065, 0x00005490},/* e x-advance: 84.562500 */ 3417 {'M', 0x429a7f24, 0xc222af3f}, 3418 {'4', 0x00300000, 0x0000fe3a}, 3419 {'q', 0x3f4e2ca0, 0x414c06de}, 3420 {0, 0x40f4d508, 0x419bb466}, 3421 {'q', 0x40dd3548, 0x40d49e12}, 3422 {0, 0x41998e9a, 0x40d49e12}, 3423 {'8', 0xf36e0038, 0xd76af335}, 3424 {'l', 0x00000000, 0x413ad87b}, 3425 {'q', 0xc0d49e10, 0x40346716}, 3426 {0, 0xc159fc8c, 0x4089731d}, 3427 {'q', 0xc0df5b10, 0x3fbcfe49}, 3428 {0, 0xc16293c4, 0x3fbcfe49}, 3429 {'q', 0xc18fe482, 0x00000000}, 3430 {0, 0xc1e4301b, 0xc127844c}, 3431 {'q', 0xc127844a, 0xc127844b}, 3432 {0, 0xc127844a, 0xc1e293c2}, 3433 {'q', 0xb5000000, 0xc193a6a8}, 3434 {0, 0x411eed1a, 0xc1ea180e}, 3435 {'q', 0x411ffffe, 0xc12df5b0}, 3436 {0, 0x41d74d4f, 0xc12df5b0}, 3437 {'q', 0x4172af40, 0x00000000}, 3438 {0, 0x41bfad88, 0x411cc750}, 3439 {'9', 0x004d0046, 0x00d40046}, 3440 {'m', 0xc1459578, 0xc067f240}, 3441 {'q', 0xbe097400, 0xc12225cc}, 3442 {0, 0xc0b68ce8, 0xc1816560}, 3443 {'q', 0xc0b01b80, 0xc0c149d8}, 3444 {0, 0xc16a180c, 0xc0c149d8}, 3445 {'q', 0xc1255e80, 0x00000000}, 3446 {0, 0xc1849e12, 0x40bad878}, 3447 {'q', 0xc0c59578, 0x40bad878}, 3448 {0, 0xc0e3a6a8, 0x41838b2a}, 3449 {'l', 0x42301b7e, 0xbd897200}, 3450 {'@', 0x00000066, 0x00003063},/* f x-advance: 48.386719 */ 3451 {'M', 0x424c06df, 0xc2d0dbeb}, 3452 {'4', 0x00520000, 0x0000ffa2}, 3453 {'8', 0x15b600cb, 0x4dec15ec}, 3454 {'l', 0x00000000, 0x40d49e10}, 3455 {'l', 0x41a2af40, 0x00000000}, 3456 {'l', 0x00000000, 0x41198ea0}, 3457 {'l', 0xc1a2af40, 0x00000000}, 3458 {'l', 0x00000000, 0x42832414}, 3459 {'l', 0xc146a85f, 0x00000000}, 3460 {'l', 0x00000000, 0xc2832414}, 3461 {'0', 0xb40000a2, 0xd700005e}, 3462 {'q', 0x00000000, 0xc148ce30}, 3463 {0, 0x40bad87a, 0xc1920a50}, 3464 {'q', 0x40bad87c, 0xc0b8b2b0}, 3465 {0, 0x4194301b, 0xc0b8b2b0}, 3466 {'l', 0x413ad87c, 0x00000000}, 3467 {'@', 0x00000067, 0x0000573f},/* g x-advance: 87.246094 */ 3468 {'M', 0x4279aa18, 0xc219d354}, 3469 {'q', 0x00000000, 0xc156c3dc}, 3470 {0, 0xc0b24150, 0xc1a67166}, 3471 {'q', 0xc0b01b78, 0xc0ec3dd8}, 3472 {0, 0xc1780dbc, 0xc0ec3dd8}, 3473 {'q', 0xc11eed1a, 0x00000000}, 3474 {0, 0xc1780dbe, 0x40ec3dd8}, 3475 {'q', 0xc0b01b80, 0x40ec3de0}, 3476 {0, 0xc0b01b80, 0x41a67166}, 3477 {'q', 0x00000000, 0x4155b0f8}, 3478 {0, 0x40b01b80, 0x41a5e7f2}, 3479 {'q', 0x40b24148, 0x40ec3dda}, 3480 {0, 0x41780dbe, 0x40ec3dda}, 3481 {'q', 0x41200000, 0x00000000}, 3482 {0, 0x41780dbc, 0xc0ec3dda}, 3483 {'9', 0xffc5002c, 0xff5b002c}, 3484 {'m', 0x41459578, 0x41e90528}, 3485 {'q', 0x00000000, 0x41998e9a}, 3486 {0, 0xc1086038, 0x41e4b98e}, 3487 {'q', 0xc1086034, 0x41154300}, 3488 {0, 0xc1d0dbea, 0x41154300}, 3489 {'8', 0xf99e00cc, 0xe8a7f8d2}, 3490 {'l', 0x00000000, 0xc14036fb}, 3491 {'8', 0x2255172b, 0x0b560b2a}, 3492 {'q', 0x41425cc4, 0x00000000}, 3493 {0, 0x419180dc, 0xc0c9e112}, 3494 {'9', 0xffcd0030, 0xff670030}, 3495 {'l', 0x00000000, 0xc0c36fb0}, 3496 {'q', 0xc074d510, 0x40d49e12}, 3497 {0, 0xc11cc750, 0x411eed1a}, 3498 {'q', 0xc0bf2410, 0x40527844}, 3499 {0, 0xc164b98c, 0x40527844}, 3500 {'q', 0xc15d3544, 0x00000000}, 3501 {0, 0xc1b2414a, 0xc1289732}, 3502 {'q', 0xc1074d50, 0xc1289732}, 3503 {0, 0xc1074d50, 0xc1df5b0f}, 3504 {'q', 0xb5000000, 0xc18b98ea}, 3505 {0, 0x41074d50, 0xc1dfe484}, 3506 {'q', 0x41074d50, 0xc1289730}, 3507 {0, 0x41b2414a, 0xc1289730}, 3508 {'q', 0x41052784, 0x00000000}, 3509 {0, 0x4164b98c, 0x40527840}, 3510 {'9', 0x001a002f, 0x004f004e}, 3511 {'l', 0x00000000, 0xc1368ce4}, 3512 {'l', 0x41459578, 0x00000000}, 3513 {'l', 0x00000000, 0x4283ad88}, 3514 {'@', 0x00000068, 0x0000571d},/* h x-advance: 87.113281 */ 3515 {'M', 0x4296df5b, 0xc23579fc}, 3516 {'4', 0x016a0000, 0x0000ff9e}, 3517 {'l', 0x00000000, 0xc233dda3}, 3518 {'q', 0x00000000, 0xc12abcfc}, 3519 {0, 0xc0852780, 0xc17f9208}, 3520 {'q', 0xc0852788, 0xc0a9aa18}, 3521 {0, 0xc147bb48, 0xc0a9aa18}, 3522 {'q', 0xc1200000, 0x00000000}, 3523 {0, 0xc17c5956, 0x40cc06d8}, 3524 {'9', 0x0033ffd2, 0x008bffd2}, 3525 {'l', 0x00000000, 0x4229eed1}, 3526 {'l', 0xc146a860, 0x00000000}, 3527 {'4', 0xfcbd0000, 0x00000063}, 3528 {'l', 0x00000000, 0x4223c225}, 3529 {'8', 0xaf53ca23, 0xe66fe630}, 3530 {'q', 0x414f3f90, 0x00000000}, 3531 {0, 0x419cc74e, 0x4100dbf0}, 3532 {'q', 0x40d49e10, 0x40ff9208}, 3533 {0, 0x40d49e10, 0x41bc74d4}, 3534 {'@', 0x00000069, 0x00002630},/* i x-advance: 38.187500 */ 3535 {'M', 0x414f3f92, 0xc29655e8}, 3536 {'l', 0x4145957a, 0x00000000}, 3537 {'4', 0x02590000, 0x0000ff9e}, 3538 {'6', 0xfda70000, 0xff160000}, 3539 {'l', 0x4145957a, 0x00000000}, 3540 {'l', 0x00000000, 0x417a3388}, 3541 {'l', 0xc145957a, 0x00000000}, 3542 {'l', 0x00000000, 0xc17a3388}, 3543 {'@', 0x0000006a, 0x00002630},/* j x-advance: 38.187500 */ 3544 {'M', 0x414f3f92, 0xc29655e8}, 3545 {'4', 0x00000062, 0x02640000}, 3546 {'q', 0x00000000, 0x4165cc71}, 3547 {0, 0xc0b01b80, 0x41a67163}, 3548 {'9', 0x0033ffd5, 0x0033ff74}, 3549 {'4', 0x0000ffdb, 0xffad0000}, 3550 {'l', 0x40527845, 0x00000000}, 3551 {'8', 0xe74c0038, 0x9414e614}, 3552 {'6', 0xfd9c0000, 0xff160000}, 3553 {'l', 0x4145957a, 0x00000000}, 3554 {'l', 0x00000000, 0x417a3388}, 3555 {'l', 0xc145957a, 0x00000000}, 3556 {'l', 0x00000000, 0xc17a3388}, 3557 {'@', 0x0000006b, 0x00004f98},/* k x-advance: 79.593750 */ 3558 {'M', 0x4147bb46, 0xc2d0dbeb}, 3559 {'l', 0x4146a860, 0x00000000}, 3560 {'l', 0x00000000, 0x4276b61e}, 3561 {'l', 0x421361ee, 0xc201aa18}, 3562 {'l', 0x417c5958, 0x00000000}, 3563 {'l', 0xc21f768d, 0x420cabd0}, 3564 {'l', 0x42262cab, 0x42200000}, 3565 {'l', 0xc180dbea, 0x00000000}, 3566 {'l', 0xc218c06e, 0xc212d87b}, 3567 {'l', 0x36000000, 0x4212d87b}, 3568 {'l', 0xc146a860, 0x00000000}, 3569 {'l', 0x00000000, 0xc2d0dbeb}, 3570 {'@', 0x0000006c, 0x00002630},/* l x-advance: 38.187500 */ 3571 {'M', 0x414f3f92, 0xc2d0dbeb}, 3572 {'l', 0x4145957a, 0x00000000}, 3573 {'l', 0x00000000, 0x42d0dbeb}, 3574 {'l', 0xc145957a, 0x00000000}, 3575 {'l', 0x00000000, 0xc2d0dbeb}, 3576 {'@', 0x0000006d, 0x000085e4},/* m x-advance: 133.890625 */ 3577 {'M', 0x428ef3f9, 0xc272f3f9}, 3578 {'q', 0x40943020, 0xc1052784}, 3579 {0, 0x41312e60, 0xc1448294}, 3580 {'q', 0x40ce2cb0, 0xc07d6c40}, 3581 {0, 0x4172af40, 0xc07d6c40}, 3582 {'q', 0x413beb60, 0x00000000}, 3583 {0, 0x4190f768, 0x410414a0}, 3584 {'9', 0x00410033, 0x00ba0033}, 3585 {'4', 0x016a0000, 0x0000ff9d}, 3586 {'l', 0x00000000, 0xc233dda3}, 3587 {'q', 0x00000000, 0xc12ce2cc}, 3588 {0, 0xc074d500, 0xc1805278}, 3589 {'q', 0xc074d500, 0xc0a78448}, 3590 {0, 0xc13ad878, 0xc0a78448}, 3591 {'q', 0xc1198ea0, 0x00000000}, 3592 {0, 0xc172af40, 0x40cc06d8}, 3593 {'9', 0x0033ffd4, 0x008bffd4}, 3594 {'4', 0x01530000, 0x0000ff9d}, 3595 {'l', 0x00000000, 0xc233dda3}, 3596 {'q', 0x00000000, 0xc12df5b0}, 3597 {0, 0xc074d510, 0xc1805278}, 3598 {'q', 0xc074d500, 0xc0a78448}, 3599 {0, 0xc13cfe48, 0xc0a78448}, 3600 {'q', 0xc11768cc, 0x00000000}, 3601 {0, 0xc1708972, 0x40ce2ca8}, 3602 {'9', 0x0033ffd4, 0x008affd4}, 3603 {'l', 0x00000000, 0x4229eed1}, 3604 {'l', 0xc146a860, 0x00000000}, 3605 {'4', 0xfda70000, 0x00000063}, 3606 {'l', 0x00000000, 0x413ad87c}, 3607 {'q', 0x40874d50, 0xc0dd3538}, 3608 {0, 0x412225ce, 0xc12338b4}, 3609 {'q', 0x40bcfe48, 0xc0527840}, 3610 {0, 0x41606df4, 0xc0527840}, 3611 {'8', 0x216f0041, 0x6044212e}, 3612 {'@', 0x0000006e, 0x0000571d},/* n x-advance: 87.113281 */ 3613 {'M', 0x4296df5b, 0xc23579fc}, 3614 {'4', 0x016a0000, 0x0000ff9e}, 3615 {'l', 0x00000000, 0xc233dda3}, 3616 {'q', 0x00000000, 0xc12abcfc}, 3617 {0, 0xc0852780, 0xc17f9208}, 3618 {'q', 0xc0852788, 0xc0a9aa18}, 3619 {0, 0xc147bb48, 0xc0a9aa18}, 3620 {'q', 0xc1200000, 0x00000000}, 3621 {0, 0xc17c5956, 0x40cc06d8}, 3622 {'9', 0x0033ffd2, 0x008bffd2}, 3623 {'l', 0x00000000, 0x4229eed1}, 3624 {'l', 0xc146a860, 0x00000000}, 3625 {'4', 0xfda70000, 0x00000063}, 3626 {'l', 0x00000000, 0x413ad87c}, 3627 {'8', 0xaf53ca23, 0xe66fe630}, 3628 {'q', 0x414f3f90, 0x00000000}, 3629 {0, 0x419cc74e, 0x4100dbf0}, 3630 {'q', 0x40d49e10, 0x40ff9208}, 3631 {0, 0x40d49e10, 0x41bc74d4}, 3632 {'@', 0x0000006f, 0x00005418},/* o x-advance: 84.093750 */ 3633 {'M', 0x42285278, 0xc2850527}, 3634 {'q', 0xc11eed18, 0x00000000}, 3635 {0, 0xc17b4670, 0x40f920a0}, 3636 {'q', 0xc0b8b2b0, 0x40f6fad8}, 3637 {0, 0xc0b8b2b0, 0x41a9aa18}, 3638 {'q', 0x00000000, 0x4157d6c2}, 3639 {0, 0x40b68ce0, 0x41aa338b}, 3640 {'q', 0x40b8b2b0, 0x40f6fad6}, 3641 {0, 0x417c5958, 0x40f6fad6}, 3642 {'q', 0x411dda34, 0x00000000}, 3643 {0, 0x417a338c, 0xc0f920a6}, 3644 {'q', 0x40b8b2b0, 0xc0f920a4}, 3645 {0, 0x40b8b2b0, 0xc1a9aa17}, 3646 {'q', 0x00000000, 0xc155b0f8}, 3647 {0, 0xc0b8b2b0, 0xc1a920a6}, 3648 {'9', 0xffc2ffd2, 0xffc2ff83}, 3649 {'m', 0x00000000, 0xc1278450}, 3650 {'q', 0x4180dbec, 0x00000000}, 3651 {0, 0x41ca6a84, 0x41278450}, 3652 {'q', 0x41131d38, 0x41278448}, 3653 {0, 0x41131d38, 0x41e7f240}, 3654 {'q', 0x00000000, 0x4193a6a8}, 3655 {0, 0xc1131d38, 0x41e7f240}, 3656 {'q', 0xc1131d30, 0x4127844d}, 3657 {0, 0xc1ca6a84, 0x4127844d}, 3658 {'q', 0xc181655e, 0xb4c00000}, 3659 {0, 0xc1caf3f9, 0xc127844c}, 3660 {'q', 0xc1120a4e, 0xc1289731}, 3661 {0, 0xc1120a4e, 0xc1e7f240}, 3662 {'q', 0xb5000000, 0xc194301c}, 3663 {0, 0x41120a4e, 0xc1e7f240}, 3664 {'q', 0x41131d36, 0xc1278450}, 3665 {0, 0x41caf3f9, 0xc1278450}, 3666 {'[', 0x002d006f, 0x0000028c}, 3667 {'@', 0x00000070, 0x0000573f},/* p x-advance: 87.246094 */ 3668 {'M', 0x41c731d3, 0xc1346716}, 3669 {'l', 0x00000000, 0x421f768c}, 3670 {'l', 0xc146a860, 0x36000000}, 3671 {'4', 0xfcc20000, 0x00000063}, 3672 {'l', 0x00000000, 0x41368ce4}, 3673 {'q', 0x407920a8, 0xc0d6c3d8}, 3674 {0, 0x411cc74e, 0xc11eed1c}, 3675 {'q', 0x40bf2410, 0xc0527840}, 3676 {0, 0x4163a6a8, 0xc0527840}, 3677 {'q', 0x415b0f74, 0x00000000}, 3678 {0, 0x41b1b7d6, 0x412df5b0}, 3679 {'q', 0x41097320, 0x412df5b4}, 3680 {0, 0x41097320, 0x41e4b990}, 3681 {'q', 0x00000000, 0x418dbeb6}, 3682 {0, 0xc1097320, 0x41e4b98e}, 3683 {'q', 0xc1086038, 0x412df5b1}, 3684 {0, 0xc1b1b7d6, 0x412df5b1}, 3685 {'q', 0xc10414a0, 0xb4c00000}, 3686 {0, 0xc163a6a8, 0xc04e2cad}, 3687 {'9', 0xffe6ffd1, 0xffb0ffb2}, 3688 {'m', 0x42280dbe, 0xc1d1eed1}, 3689 {'q', 0x00000000, 0xc159fc90}, 3690 {0, 0xc0b46718, 0xc1aabcfe}, 3691 {'q', 0xc0b24148, 0xc0f920a8}, 3692 {0, 0xc175e7f0, 0xc0f920a8}, 3693 {'q', 0xc11cc750, 0x00000000}, 3694 {0, 0xc176fada, 0x40f920a8}, 3695 {'q', 0xc0b24148, 0x40f6fad8}, 3696 {0, 0xc0b24148, 0x41aabcfe}, 3697 {'q', 0x00000000, 0x4159fc90}, 3698 {0, 0x40b24148, 0x41ab4671}, 3699 {'q', 0x40b46714, 0x40f6fad8}, 3700 {0, 0x4176fada, 0x40f6fad8}, 3701 {'q', 0x411cc74c, 0x00000000}, 3702 {0, 0x4175e7f0, 0xc0f6fad8}, 3703 {'q', 0x40b46718, 0xc0f920a4}, 3704 {0, 0x40b46718, 0xc1ab4671}, 3705 {'@', 0x00000071, 0x0000573f},/* q x-advance: 87.246094 */ 3706 {'M', 0x41a2af3f, 0xc216112e}, 3707 {'q', 0x00000000, 0x4159fc90}, 3708 {0, 0x40b2414c, 0x41ab4671}, 3709 {'q', 0x40b46714, 0x40f6fad8}, 3710 {0, 0x4176fad8, 0x40f6fad8}, 3711 {'q', 0x411cc74c, 0x00000000}, 3712 {0, 0x4176fad8, 0xc0f6fad8}, 3713 {'q', 0x40b46718, 0xc0f920a4}, 3714 {0, 0x40b46718, 0xc1ab4671}, 3715 {'q', 0x00000000, 0xc159fc90}, 3716 {0, 0xc0b46718, 0xc1aabcfe}, 3717 {'q', 0xc0b46718, 0xc0f920a8}, 3718 {0, 0xc176fad8, 0xc0f920a8}, 3719 {'q', 0xc11cc74e, 0x00000000}, 3720 {0, 0xc176fad8, 0x40f920a8}, 3721 {'9', 0x003dffd4, 0x00aaffd4}, 3722 {'m', 0x42285278, 0x41d1eed1}, 3723 {'q', 0xc07920b0, 0x40d6c3dd}, 3724 {0, 0xc11dda34, 0x41200000}, 3725 {'q', 0xc0bcfe48, 0x404e2caa}, 3726 {0, 0xc163a6a8, 0x404e2caa}, 3727 {'q', 0xc159fc90, 0x34000000}, 3728 {0, 0xc1b1b7d7, 0xc12df5b0}, 3729 {'q', 0xc1086036, 0xc12df5b0}, 3730 {0, 0xc1086036, 0xc1e4b98e}, 3731 {'q', 0xb5000000, 0xc18dbeb6}, 3732 {0, 0x41086036, 0xc1e4b990}, 3733 {'q', 0x4109731e, 0xc12df5b0}, 3734 {0, 0x41b1b7d7, 0xc12df5b0}, 3735 {'q', 0x41052784, 0x00000000}, 3736 {0, 0x4163a6a8, 0x40527840}, 3737 {'9', 0x0019002f, 0x004f004e}, 3738 {'l', 0x00000000, 0xc1368ce4}, 3739 {'l', 0x41459578, 0x00000000}, 3740 {'l', 0x00000000, 0x42cf844c}, 3741 {'l', 0xc1459578, 0xb6800000}, 3742 {'l', 0x00000000, 0xc21f768c}, 3743 {'@', 0x00000072, 0x00003882},/* r x-advance: 56.507812 */ 3744 {'M', 0x42620a4f, 0xc27e7f24}, 3745 {'8', 0xf3dcf7f0, 0xfcd6fced}, 3746 {'q', 0xc127844c, 0x00000000}, 3747 {0, 0xc180dbeb, 0x40db0f78}, 3748 {'9', 0x0036ffd4, 0x009cffd4}, 3749 {'l', 0x00000000, 0x421e63a6}, 3750 {'l', 0xc146a860, 0x00000000}, 3751 {'4', 0xfda70000, 0x00000063}, 3752 {'l', 0x00000000, 0x413ad87c}, 3753 {'q', 0x407920a8, 0xc0db0f78}, 3754 {0, 0x412225ce, 0xc12225cc}, 3755 {'q', 0x40c7bb40, 0xc056c3e0}, 3756 {0, 0x4172af3c, 0xc056c3e0}, 3757 {'8', 0x0116000a, 0x031b010c}, 3758 {'l', 0x3d897400, 0x414af3f8}, 3759 {'@', 0x00000073, 0x0000479c},/* s x-advance: 71.609375 */ 3760 {'M', 0x42737d6c, 0xc291e7f2}, 3761 {'l', 0x00000000, 0x413ad87c}, 3762 {'8', 0xe0aaebd7, 0xf6a3f6d3}, 3763 {'8', 0x169200b7, 0x43dc16dc}, 3764 {'8', 0x361a2200, 0x2569131a}, 3765 {'l', 0x40874d50, 0x3f708980}, 3766 {'q', 0x41527844, 0x40346720}, 3767 {0, 0x41954302, 0x40ff9208}, 3768 {'q', 0x40b24150, 0x40a338b4}, 3769 {0, 0x40b24150, 0x4164b990}, 3770 {'q', 0x00000000, 0x4127844b}, 3771 {0, 0xc1052788, 0x41849e11}, 3772 {'q', 0xc104149c, 0x40c36fad}, 3773 {0, 0xc1b6036e, 0x40c36fad}, 3774 {'8', 0xf79c00d0, 0xe492f7cc}, 3775 {'l', 0x00000000, 0xc14c06df}, 3776 {'8', 0x2a6b1c36, 0x0d690d35}, 3777 {'8', 0xe96b0045, 0xbd25e825}, 3778 {'q', 0x00000000, 0xc0a112e8}, 3779 {0, 0xc05b0f70, 0xc0f6fad8}, 3780 {'9', 0xffebffe6, 0xffd7ff8a}, 3781 {'l', 0xc0897320, 0xbf80dbe0}, 3782 {'q', 0xc1379fc8, 0xc01aa180}, 3783 {0, 0xc1849e11, 0xc0ec3de0}, 3784 {'q', 0xc0a338b2, 0xc0a112e0}, 3785 {0, 0xc0a338b2, 0xc15c225c}, 3786 {'q', 0x00000000, 0xc129aa18}, 3787 {0, 0x40f08972, 0xc18301b8}, 3788 {'q', 0x40f08974, 0xc0b8b2b0}, 3789 {0, 0x41aabcff, 0xc0b8b2b0}, 3790 {'8', 0x08670036, 0x18590830}, 3791 {'@', 0x00000074, 0x000035e4},/* t x-advance: 53.890625 */ 3792 {'M', 0x41c9579f, 0xc2c10527}, 3793 {'l', 0x00000000, 0x41aabcfc}, 3794 {'l', 0x41cb7d6d, 0x00000000}, 3795 {'4', 0x004c0000, 0x0000ff35}, 3796 {'l', 0x00000000, 0x422338b2}, 3797 {'8', 0x5e134900, 0x14521414}, 3798 {'4', 0x00000065, 0x00520000}, 3799 {'l', 0xc14af3f8, 0x00000000}, 3800 {'q', 0xc164b990, 0x00000000}, 3801 {0, 0xc19dda34, 0xc0a9aa18}, 3802 {'9', 0xffd6ffd5, 0xff65ffd5}, 3803 {'l', 0x00000000, 0xc22338b2}, 3804 {'l', 0xc110f768, 0x00000000}, 3805 {'l', 0xb5000000, 0xc1198ea0}, 3806 {'l', 0x4110f768, 0x00000000}, 3807 {'l', 0x35800000, 0xc1aabcfc}, 3808 {'l', 0x4146a85f, 0x00000000}, 3809 {'@', 0x00000075, 0x0000571d},/* u x-advance: 87.113281 */ 3810 {'M', 0x413ad87b, 0xc1ed50c0}, 3811 {'4', 0xfe940000, 0x00000062}, 3812 {'l', 0x00000000, 0x4234225d}, 3813 {'q', 0x00000000, 0x412abcfe}, 3814 {0, 0x40852784, 0x41805278}, 3815 {'q', 0x40852780, 0x40a9aa18}, 3816 {0, 0x4147bb44, 0x40a9aa18}, 3817 {'q', 0x41200000, 0x00000000}, 3818 {0, 0x417c5958, 0xc0cc06de}, 3819 {'9', 0xffcd002e, 0xff75002e}, 3820 {'l', 0x00000000, 0xc22a7845}, 3821 {'l', 0x41459574, 0x00000000}, 3822 {'4', 0x02590000, 0x0000ff9e}, 3823 {'l', 0x00000000, 0xc138b2af}, 3824 {'8', 0x51ad36dd, 0x1a921ad1}, 3825 {'q', 0xc14f3f94, 0x34000000}, 3826 {0, 0xc19d50c1, 0xc100dbeb}, 3827 {'9', 0xffc0ffcb, 0xff44ffcb}, 3828 {'m', 0x41f89732, 0xc23d4302}, 3829 {'l', 0x00000000, 0x00000000}, 3830 {'@', 0x00000076, 0x00005157},/* v x-advance: 81.339844 */ 3831 {'M', 0x408301b8, 0xc29655e8}, 3832 {'l', 0x4151655e, 0x00000000}, 3833 {'l', 0x41bbeb61, 0x427c5958}, 3834 {'l', 0x41bbeb62, 0xc27c5958}, 3835 {'l', 0x41516560, 0x00000000}, 3836 {'l', 0xc1e180dc, 0x429655e8}, 3837 {'l', 0xc1863a6a, 0x00000000}, 3838 {'l', 0xc1e180dc, 0xc29655e8}, 3839 {'@', 0x00000077, 0x0000706a},/* w x-advance: 112.414062 */ 3840 {'M', 0x40b8b2af, 0xc29655e8}, 3841 {'l', 0x4145957a, 0x00000000}, 3842 {'l', 0x4176fad6, 0x426aa181}, 3843 {'l', 0x4175e7f4, 0xc26aa181}, 3844 {'l', 0x41690528, 0x00000000}, 3845 {'l', 0x4176fad4, 0x426aa181}, 3846 {'l', 0x4175e7f8, 0xc26aa181}, 3847 {'l', 0x41459578, 0x00000000}, 3848 {'l', 0xc19d50c0, 0x429655e8}, 3849 {'l', 0xc1690528, 0x00000000}, 3850 {'l', 0xc1816560, 0xc2767165}, 3851 {'l', 0xc181eed0, 0x42767165}, 3852 {'l', 0xc1690528, 0x00000000}, 3853 {'l', 0xc19d50c0, 0xc29655e8}, 3854 {'@', 0x00000078, 0x00005157},/* x x-advance: 81.339844 */ 3855 {'M', 0x4296df5b, 0xc29655e8}, 3856 {'l', 0xc1d9731e, 0x42124f09}, 3857 {'l', 0x41e4b98e, 0x421a5cc7}, 3858 {'l', 0xc1690524, 0x00000000}, 3859 {'l', 0xc1af0898, 0xc1ec3dda}, 3860 {'l', 0xc1af0897, 0x41ec3dda}, 3861 {'l', 0xc1690527, 0x00000000}, 3862 {'l', 0x41e98e9a, 0xc21d50c0}, 3863 {'l', 0xc1d5b0f7, 0xc20f5b10}, 3864 {'l', 0x41690526, 0x00000000}, 3865 {'l', 0x419f768e, 0x41d63a6c}, 3866 {'l', 0x419f768c, 0xc1d63a6c}, 3867 {'l', 0x41690528, 0x00000000}, 3868 {'@', 0x00000079, 0x00005157},/* y x-advance: 81.339844 */ 3869 {'M', 0x4230e9aa, 0x40df5b0f}, 3870 {'q', 0xc0a78450, 0x4156c3dc}, 3871 {0, 0xc12338b4, 0x418c225c}, 3872 {'9', 0x0020ffd9, 0x0020ff96}, 3873 {'4', 0x0000ffb2, 0xffae0000}, 3874 {'l', 0x40e7f242, 0x00000000}, 3875 {'8', 0xed3f0028, 0xa531ed16}, 3876 {'l', 0x400dbeb0, 0xc0b46716}, 3877 {'l', 0xc1f338b2, 0xc293eb62}, 3878 {'l', 0x4151655e, 0x00000000}, 3879 {'l', 0x41bbeb61, 0x426b2af4}, 3880 {'l', 0x41bbeb62, 0xc26b2af4}, 3881 {'l', 0x41516560, 0x00000000}, 3882 {'l', 0xc204149e, 0x42a44b99}, 3883 {'@', 0x0000007a, 0x00004825},/* z x-advance: 72.144531 */ 3884 {'M', 0x40f2af3f, 0xc29655e8}, 3885 {'l', 0x426aa180, 0x00000000}, 3886 {'l', 0x00000000, 0x41346718}, 3887 {'l', 0xc239c595, 0x42581b7d}, 3888 {'l', 0x4239c595, 0x35800000}, 3889 {'l', 0x00000000, 0x411dda33}, 3890 {'l', 0xc271579f, 0x00000000}, 3891 {'l', 0x00000000, 0xc1346716}, 3892 {'l', 0x4239c595, 0xc2581b7c}, 3893 {'l', 0xc2330f76, 0x00000000}, 3894 {'l', 0xb5000000, 0xc11dda38}, 3895 {'@', 0x0000007b, 0x00005773},/* { x-advance: 87.449219 */ 3896 {'M', 0x428c8973, 0x414c06df}, 3897 {'4', 0x004d0000, 0x0000ffdf}, 3898 {'q', 0xc185b0f8, 0x00000000}, 3899 {0, 0xc1b35432, 0xc09eed1c}, 3900 {'9', 0xffd9ffd3, 0xff62ffd3}, 3901 {'l', 0x00000000, 0xc1805278}, 3902 {'q', 0x00000000, 0xc12225cc}, 3903 {0, 0xc067f240, 0xc1606df6}, 3904 {'9', 0xffe1ffe4, 0xffe1ff97}, 3905 {'4', 0x0000ffe0, 0xffb40000}, 3906 {'l', 0x408301b8, 0x00000000}, 3907 {'8', 0xe269004c, 0x911ce11c}, 3908 {'l', 0x00000000, 0xc180dbec}, 3909 {'q', 0x00000000, 0xc16d50c0}, 3910 {0, 0x40b46710, 0xc19dda30}, 3911 {'9', 0xffd9002d, 0xffd900b3}, 3912 {'4', 0x00000021, 0x004c0000}, 3913 {'l', 0xc0920a50, 0x00000000}, 3914 {'8', 0x179e00b5, 0x63e917e9}, 3915 {'l', 0x00000000, 0x41852786}, 3916 {'q', 0x00000000, 0x41289730}, 3917 {0, 0xc0459580, 0x4174d50c}, 3918 {'8', 0x33ad26e8, 0x34530e3b}, 3919 {'9', 0x00260018, 0x00790018}, 3920 {'l', 0x00000000, 0x41852785}, 3921 {'8', 0x63174b00, 0x17621717}, 3922 {'l', 0x40920a50, 0x00000000}, 3923 {'@', 0x0000007c, 0x00002e4f},/* | x-advance: 46.308594 */ 3924 {'M', 0x41e6df5b, 0xc2d2112e}, 3925 {'l', 0x00000000, 0x4309731d}, 3926 {'l', 0xc1368ce4, 0x00000000}, 3927 {'l', 0x00000000, 0xc309731d}, 3928 {'l', 0x41368ce4, 0x00000000}, 3929 {'@', 0x0000007d, 0x00005773},/* } x-advance: 87.449219 */ 3930 {'M', 0x4189731d, 0x414c06df}, 3931 {'l', 0x409655e8, 0x00000000}, 3932 {'8', 0xe961004b, 0x9d17e917}, 3933 {'l', 0x00000000, 0xc1852784}, 3934 {'q', 0x00000000, 0xc127844a}, 3935 {0, 0x404149e0, 0xc173c224}, 3936 {'8', 0xcc53da18, 0xcdadf3c5}, 3937 {'9', 0xffdaffe8, 0xff86ffe8}, 3938 {'l', 0x00000000, 0xc1852786}, 3939 {'8', 0x9de9b400, 0xe99fe9ea}, 3940 {'4', 0x0000ffdb, 0xffb40000}, 3941 {'l', 0x40874d50, 0x00000000}, 3942 {'q', 0x4185b0f7, 0x00000000}, 3943 {0, 0x41b24149, 0x409eed20}, 3944 {'9', 0x0027002d, 0x009d002d}, 3945 {'l', 0x00000000, 0x4180dbec}, 3946 {'8', 0x6f1c5000, 0x1e691e1c}, 3947 {'4', 0x00000021, 0x004c0000}, 3948 {'l', 0xc0852780, 0x00000000}, 3949 {'q', 0xc1187bb8, 0x00000000}, 3950 {0, 0xc1527848, 0x407920a0}, 3951 {'9', 0x001fffe4, 0x0070ffe4}, 3952 {'l', 0x00000000, 0x41805278}, 3953 {'q', 0x00000000, 0x416d50c0}, 3954 {0, 0xc0b46718, 0x419e63a6}, 3955 {'9', 0x0027ffd4, 0x0027ff4e}, 3956 {'l', 0xc0874d50, 0x00000000}, 3957 {'l', 0x00000000, 0xc11aa181}, 3958 {'@', 0x0000007e, 0x0000732a},/* ~ x-advance: 115.164062 */ 3959 {'M', 0x42c93543, 0xc25b5430}, 3960 {'l', 0x00000000, 0x413f2414}, 3961 {'8', 0x3c982ac8, 0x129d12d1}, 3962 {'q', 0xc0ec3dd0, 0x00000000}, 3963 {0, 0xc189731c, 0xc07d6c40}, 3964 {'8', 0xfdf8fefb, 0xfcf5fffd}, 3965 {'q', 0xc1267168, 0xc0852780}, 3966 {0, 0xc185b0f8, 0xc0852780}, 3967 {'8', 0x14a300d1, 0x409e14d2}, 3968 {'l', 0x00000000, 0xc13f2414}, 3969 {'8', 0xc468d638, 0xee64ee30}, 3970 {'q', 0x40ec3dd8, 0x00000000}, 3971 {0, 0x4189fc90, 0x4080dbe8}, 3972 {'8', 0x03080205, 0x040b0104}, 3973 {'q', 0x41267164, 0x40852780}, 3974 {0, 0x4185b0f6, 0x40852780}, 3975 {'8', 0xec5b002e, 0xbf64ec2d}, 3976 }; 3977 #define CTX_FONT_ascii 1 3978 #endif 3979 #endif //_CTX_INTERNAL_FONT_ 3980 #ifndef __CTX_LIST__ 3981 #define __CTX_LIST__ 3982 3983 #if !__COSMOPOLITAN__ 3984 #include <stdlib.h> 3985 #endif 3986 3987 /* The whole ctx_list implementation is in the header and will be inlined 3988 * wherever it is used. 3989 */ 3990 3991 static inline void *ctx_calloc (size_t size, size_t count) 3992 { 3993 size_t byte_size = size * count; 3994 char *ret = (char*)malloc (byte_size); 3995 for (size_t i = 0; i < byte_size; i++) 3996 ret[i] = 0; 3997 return ret; 3998 } 3999 4000 typedef struct _CtxList CtxList; 4001 struct _CtxList { 4002 void *data; 4003 CtxList *next; 4004 void (*freefunc)(void *data, void *freefunc_data); 4005 void *freefunc_data; 4006 }; 4007 4008 static inline void ctx_list_prepend_full (CtxList **list, void *data, 4009 void (*freefunc)(void *data, void *freefunc_data), 4010 void *freefunc_data) 4011 { 4012 CtxList *new_= (CtxList*)ctx_calloc (sizeof (CtxList), 1); 4013 new_->next = *list; 4014 new_->data=data; 4015 new_->freefunc=freefunc; 4016 new_->freefunc_data = freefunc_data; 4017 *list = new_; 4018 } 4019 4020 static inline int ctx_list_length (CtxList *list) 4021 { 4022 int length = 0; 4023 CtxList *l; 4024 for (l = list; l; l = l->next, length++); 4025 return length; 4026 } 4027 4028 static inline void ctx_list_prepend (CtxList **list, void *data) 4029 { 4030 CtxList *new_ = (CtxList*) ctx_calloc (sizeof (CtxList), 1); 4031 new_->next= *list; 4032 new_->data=data; 4033 *list = new_; 4034 } 4035 4036 static inline CtxList *ctx_list_nth (CtxList *list, int no) 4037 { 4038 while (no-- && list) 4039 { list = list->next; } 4040 return list; 4041 } 4042 4043 static inline void *ctx_list_nth_data (CtxList *list, int no) 4044 { 4045 CtxList *l = ctx_list_nth (list, no); 4046 if (l) 4047 return l->data; 4048 return NULL; 4049 } 4050 4051 4052 static inline void 4053 ctx_list_insert_before (CtxList **list, CtxList *sibling, 4054 void *data) 4055 { 4056 if (*list == NULL || *list == sibling) 4057 { 4058 ctx_list_prepend (list, data); 4059 } 4060 else 4061 { 4062 CtxList *prev = NULL; 4063 for (CtxList *l = *list; l; l=l->next) 4064 { 4065 if (l == sibling) 4066 { break; } 4067 prev = l; 4068 } 4069 if (prev) 4070 { 4071 CtxList *new_ = (CtxList*)ctx_calloc (sizeof (CtxList), 1); 4072 new_->next = sibling; 4073 new_->data = data; 4074 prev->next=new_; 4075 } 4076 } 4077 } 4078 4079 static inline void ctx_list_remove_link (CtxList **list, CtxList *link) 4080 { 4081 CtxList *iter, *prev = NULL; 4082 if ((*list) == link) 4083 { 4084 prev = (*list)->next; 4085 *list = prev; 4086 link->next = NULL; 4087 return; 4088 } 4089 for (iter = *list; iter; iter = iter->next) 4090 if (iter == link) 4091 { 4092 if (prev) 4093 prev->next = iter->next; 4094 link->next = NULL; 4095 return; 4096 } 4097 else 4098 prev = iter; 4099 } 4100 4101 static inline void ctx_list_remove (CtxList **list, void *data) 4102 { 4103 CtxList *iter, *prev = NULL; 4104 if ((*list)->data == data) 4105 { 4106 if ((*list)->freefunc) 4107 (*list)->freefunc ((*list)->data, (*list)->freefunc_data); 4108 prev = (*list)->next; 4109 free (*list); 4110 *list = prev; 4111 return; 4112 } 4113 for (iter = *list; iter; iter = iter->next) 4114 if (iter->data == data) 4115 { 4116 if (iter->freefunc) 4117 iter->freefunc (iter->data, iter->freefunc_data); 4118 prev->next = iter->next; 4119 free (iter); 4120 break; 4121 } 4122 else 4123 prev = iter; 4124 } 4125 4126 static inline void ctx_list_free (CtxList **list) 4127 { 4128 while (*list) 4129 ctx_list_remove (list, (*list)->data); 4130 } 4131 4132 static inline void 4133 ctx_list_reverse (CtxList **list) 4134 { 4135 CtxList *new_ = NULL; 4136 CtxList *l; 4137 for (l = *list; l; l=l->next) 4138 ctx_list_prepend (&new_, l->data); 4139 ctx_list_free (list); 4140 *list = new_; 4141 } 4142 4143 static inline void *ctx_list_last (CtxList *list) 4144 { 4145 if (list) 4146 { 4147 CtxList *last; 4148 for (last = list; last->next; last=last->next); 4149 return last->data; 4150 } 4151 return NULL; 4152 } 4153 4154 static inline void ctx_list_concat (CtxList **list, CtxList *list_b) 4155 { 4156 if (*list) 4157 { 4158 CtxList *last; 4159 for (last = *list; last->next; last=last->next); 4160 last->next = list_b; 4161 return; 4162 } 4163 *list = list_b; 4164 } 4165 4166 static inline void ctx_list_append_full (CtxList **list, void *data, 4167 void (*freefunc)(void *data, void *freefunc_data), 4168 void *freefunc_data) 4169 { 4170 CtxList *new_ = (CtxList*) ctx_calloc (sizeof (CtxList), 1); 4171 new_->data=data; 4172 new_->freefunc = freefunc; 4173 new_->freefunc_data = freefunc_data; 4174 ctx_list_concat (list, new_); 4175 } 4176 4177 static inline void ctx_list_append (CtxList **list, void *data) 4178 { 4179 ctx_list_append_full (list, data, NULL, NULL); 4180 } 4181 4182 static inline void 4183 ctx_list_insert_at (CtxList **list, 4184 int no, 4185 void *data) 4186 { 4187 if (*list == NULL || no == 0) 4188 { 4189 ctx_list_prepend (list, data); 4190 } 4191 else 4192 { 4193 int pos = 0; 4194 CtxList *prev = NULL; 4195 CtxList *sibling = NULL; 4196 for (CtxList *l = *list; l && pos < no; l=l->next) 4197 { 4198 prev = sibling; 4199 sibling = l; 4200 pos ++; 4201 } 4202 if (prev) 4203 { 4204 CtxList *new_ = (CtxList*)ctx_calloc (sizeof (CtxList), 1); 4205 new_->next = sibling; 4206 new_->data = data; 4207 prev->next=new_; 4208 return; 4209 } 4210 ctx_list_append (list, data); 4211 } 4212 } 4213 4214 static CtxList* 4215 ctx_list_merge_sorted (CtxList* list1, 4216 CtxList* list2, 4217 int(*compare)(const void *a, const void *b, void *userdata), void 4218 *userdata 4219 ) 4220 { 4221 if (list1 == NULL) 4222 return(list2); 4223 else if (list2==NULL) 4224 return(list1); 4225 4226 if (compare (list1->data, list2->data, userdata) >= 0) 4227 { 4228 list1->next = ctx_list_merge_sorted (list1->next,list2, compare, 4229 userdata); 4230 /*list1->next->prev = list1; 4231 list1->prev = NULL;*/ 4232 return list1; 4233 } 4234 else 4235 { 4236 list2->next = ctx_list_merge_sorted (list1,list2->next, compare, 4237 userdata); 4238 /*list2->next->prev = list2; 4239 list2->prev = NULL;*/ 4240 return list2; 4241 } 4242 } 4243 4244 static void 4245 ctx_list_split_half (CtxList* head, 4246 CtxList** list1, 4247 CtxList** list2) 4248 { 4249 CtxList* fast; 4250 CtxList* slow; 4251 if (head==NULL || head->next==NULL) 4252 { 4253 *list1 = head; 4254 *list2 = NULL; 4255 } 4256 else 4257 { 4258 slow = head; 4259 fast = head->next; 4260 4261 while (fast != NULL) 4262 { 4263 fast = fast->next; 4264 if (fast != NULL) 4265 { 4266 slow = slow->next; 4267 fast = fast->next; 4268 } 4269 } 4270 4271 *list1 = head; 4272 *list2 = slow->next; 4273 slow->next = NULL; 4274 } 4275 } 4276 4277 static inline void ctx_list_sort (CtxList **head, 4278 int(*compare)(const void *a, const void *b, void *userdata), 4279 void *userdata) 4280 { 4281 CtxList* list1; 4282 CtxList* list2; 4283 4284 /* Base case -- length 0 or 1 */ 4285 if ((*head == NULL) || ((*head)->next == NULL)) 4286 { 4287 return; 4288 } 4289 4290 ctx_list_split_half (*head, &list1, &list2); 4291 ctx_list_sort (&list1, compare, userdata); 4292 ctx_list_sort (&list2, compare, userdata); 4293 *head = ctx_list_merge_sorted (list1, list2, compare, userdata); 4294 } 4295 4296 static inline void ctx_list_insert_sorted (CtxList **list, 4297 void *item, 4298 int(*compare)(const void *a, const void *b, void *userdata), 4299 void *userdata) 4300 { 4301 ctx_list_prepend (list, item); 4302 ctx_list_sort (list, compare, userdata); 4303 } 4304 4305 4306 static inline CtxList *ctx_list_find_custom (CtxList *list, 4307 void *needle, 4308 int(*compare)(const void *a, const 4309 void *b), 4310 void *userdata) 4311 { 4312 CtxList *l; 4313 for (l = list; l; l = l->next) 4314 { 4315 if (compare (l->data, needle) == 0) 4316 return l; 4317 } 4318 return NULL; 4319 } 4320 4321 #endif 4322 /* definitions that determine which features are included and their 4323 settings, 4324 * for particular platforms - in particular microcontrollers ctx might need 4325 * tuning for different quality/performance/resource constraints. 4326 * 4327 * the way to configure ctx is to set these defines, before both including 4328 it 4329 * as a header and in the file where CTX_IMPLEMENTATION is set to include 4330 the 4331 * implementation for different featureset and runtime settings. 4332 * 4333 */ 4334 4335 /* whether the font rendering happens in backend or front-end of API, the 4336 * option is used set to 0 by the tool that converts ttf fonts to ctx 4337 internal 4338 * representation - both should be possible so that this tool can be made 4339 * into a TTF/OTF font import at runtime (perhaps even with live subsetting) 4340 . 4341 */ 4342 #ifndef CTX_BACKEND_TEXT 4343 #define CTX_BACKEND_TEXT 1 4344 #endif 4345 4346 4347 #define CTX_RASTERIZER_AA_SLOPE_LIMIT3 (65536/CTX_SUBDIV/15) 4348 #define CTX_RASTERIZER_AA_SLOPE_LIMIT3_FAST_AA (65536/CTX_SUBDIV/15) 4349 //#define CTX_RASTERIZER_AA_SLOPE_LIMIT3_FAST_AA (120536/CTX_SUBDIV/15) 4350 //#define CTX_RASTERIZER_AA_SLOPE_LIMIT3_FAST_AA (105000/CTX_SUBDIV/15) 4351 #define CTX_RASTERIZER_AA_SLOPE_LIMIT5 (140425/CTX_SUBDIV/15) 4352 #define CTX_RASTERIZER_AA_SLOPE_LIMIT15 (260425/CTX_SUBDIV/15) 4353 4354 /* subpixel-aa coordinates used in BITPACKing of drawlist 4355 * 4356 * powers of 2 is faster 4357 */ 4358 #ifndef CTX_SUBDIV 4359 #define CTX_SUBDIV 8 // max framebufer width 4095 4360 //#define CTX_SUBDIV 10 // max framebufer width 3250 4361 //#define CTX_SUBDIV 16 // max framebufer width 2047 4362 //#define CTX_SUBDIV 24 // max framebufer width 1350 4363 //#define CTX_SUBDIV 32 // max framebufer width 1023 4364 #endif 4365 4366 4367 // 8 12 68 40 24 4368 // 16 12 68 40 24 4369 /* scale-factor for font outlines prior to bit quantization by CTX_SUBDIV 4370 * 4371 * changing this also changes font file format - the value should be baked 4372 * into the ctxf files making them less dependent on the ctx used to 4373 * generate them 4374 */ 4375 #define CTX_BAKE_FONT_SIZE 160 4376 4377 /* pack some linetos/curvetos/movetos into denser drawlist instructions, 4378 * permitting more vectors to be stored in the same space, experimental 4379 * feature with added overhead. 4380 */ 4381 #ifndef CTX_BITPACK 4382 #define CTX_BITPACK 1 4383 #endif 4384 4385 /* whether we have a shape-cache where we keep pre-rasterized bitmaps of 4386 * commonly occuring small shapes, disabled by default since it has some 4387 * glitches (and potential hangs with multi threading). 4388 */ 4389 #ifndef CTX_SHAPE_CACHE 4390 #define CTX_SHAPE_CACHE 0 4391 #endif 4392 4393 /* size (in pixels, w*h) that we cache rasterization for 4394 */ 4395 #ifndef CTX_SHAPE_CACHE_DIM 4396 #define CTX_SHAPE_CACHE_DIM (16*8) 4397 #endif 4398 4399 #ifndef CTX_SHAPE_CACHE_MAX_DIM 4400 #define CTX_SHAPE_CACHE_MAX_DIM 20 4401 #endif 4402 4403 /* maximum number of entries in shape cache 4404 */ 4405 #ifndef CTX_SHAPE_CACHE_ENTRIES 4406 #define CTX_SHAPE_CACHE_ENTRIES 160 4407 #endif 4408 4409 4410 #ifndef CTX_PARSER_FIXED_TEMP 4411 #define CTX_PARSER_FIXED_TEMP 0 4412 // when 1 CTX_PARSER_MAXLEN is the fixed max stringlen 4413 #endif // and no allocations happens beyond creating the parser, 4414 // when 0 the scratchbuf for parsing is a separate dynamically 4415 // growing buffer, that maxes out at CTX_PARSER_MAXLEN 4416 // 4417 #ifndef CTX_PARSER_MAXLEN 4418 #if CTX_PARSER_FIXED_TEMP 4419 #define CTX_PARSER_MAXLEN 1024*128 // This is the maximum 4420 texture/string size supported 4421 #else 4422 #define CTX_PARSER_MAXLEN 1024*1024*16 // 16mb 4423 #endif 4424 #endif 4425 4426 #ifndef CTX_COMPOSITING_GROUPS 4427 #define CTX_COMPOSITING_GROUPS 1 4428 #endif 4429 4430 /* maximum nesting level of compositing groups 4431 */ 4432 #ifndef CTX_GROUP_MAX 4433 #define CTX_GROUP_MAX 8 4434 #endif 4435 4436 #ifndef CTX_ENABLE_CLIP 4437 #define CTX_ENABLE_CLIP 1 4438 #endif 4439 4440 /* use a 1bit clip buffer, saving RAM on microcontrollers, other rendering 4441 * will still be antialiased. 4442 */ 4443 #ifndef CTX_1BIT_CLIP 4444 #define CTX_1BIT_CLIP 0 4445 #endif 4446 4447 4448 #ifndef CTX_ENABLE_SHADOW_BLUR 4449 #define CTX_ENABLE_SHADOW_BLUR 1 4450 #endif 4451 4452 #ifndef CTX_GRADIENTS 4453 #define CTX_GRADIENTS 1 4454 #endif 4455 4456 #ifndef CTX_ALIGNED_STRUCTS 4457 #define CTX_ALIGNED_STRUCTS 1 4458 #endif 4459 4460 #ifndef CTX_GRADIENT_CACHE 4461 #define CTX_GRADIENT_CACHE 1 4462 #endif 4463 4464 #ifndef CTX_FONTS_FROM_FILE 4465 #define CTX_FONTS_FROM_FILE 0 4466 #endif 4467 4468 #ifndef CTX_GET_CONTENTS 4469 #if CTX_FONTS_FROM_FILE 4470 #define CTX_GET_CONTENTS 1 4471 #else 4472 #define CTX_GET_CONTENTS 0 4473 #endif 4474 #endif 4475 4476 #ifndef CTX_FORMATTER 4477 #define CTX_FORMATTER 1 4478 #endif 4479 4480 #ifndef CTX_PARSER 4481 #define CTX_PARSER 1 4482 #endif 4483 4484 #ifndef CTX_CURRENT_PATH 4485 #define CTX_CURRENT_PATH 1 4486 #endif 4487 4488 #ifndef CTX_XML 4489 #define CTX_XML 1 4490 #endif 4491 4492 #ifndef CTX_VT 4493 #define CTX_VT 0 4494 #endif 4495 4496 /* when ctx_math is defined, which it is by default, we use ctx' own 4497 * implementations of math functions, instead of relying on math.h 4498 * the possible inlining gives us a slight speed-gain, and on 4499 * embedded platforms guarantees that we do not do double precision 4500 * math. 4501 */ 4502 #ifndef CTX_MATH 4503 #define CTX_MATH 1 // use internal fast math for sqrt,sin,cos, 4504 atan2f etc. 4505 #endif 4506 4507 #define ctx_log(fmt, ...) 4508 //#define ctx_log(str, a...) fprintf(stderr, str, ##a) 4509 4510 /* the initial journal size - for both rasterizer 4511 * edgelist and drawlist. 4512 */ 4513 #ifndef CTX_MIN_JOURNAL_SIZE 4514 #define CTX_MIN_JOURNAL_SIZE 512 4515 #endif 4516 4517 /* The maximum size we permit the drawlist to grow to, 4518 * the memory used is this number * 9, where 9 is sizeof(CtxEntry) 4519 */ 4520 #ifndef CTX_MAX_JOURNAL_SIZE 4521 //#define CTX_MAX_JOURNAL_SIZE CTX_MIN_JOURNAL_SIZE 4522 #define CTX_MAX_JOURNAL_SIZE 1024*1024*16 4523 #endif 4524 4525 #ifndef CTX_DRAWLIST_STATIC 4526 #define CTX_DRAWLIST_STATIC 0 4527 #endif 4528 4529 #ifndef CTX_MIN_EDGE_LIST_SIZE 4530 #define CTX_MIN_EDGE_LIST_SIZE 1024 4531 #endif 4532 4533 #ifndef CTX_RASTERIZER_AA 4534 #define CTX_RASTERIZER_AA 15 // vertical-AA of CTX_ANTIALIAS_DEFAULT 4535 #endif 4536 4537 /* The maximum complexity of a single path 4538 */ 4539 #ifndef CTX_MAX_EDGE_LIST_SIZE 4540 #define CTX_MAX_EDGE_LIST_SIZE CTX_MIN_EDGE_LIST_SIZE 4541 #endif 4542 4543 #ifndef CTX_STRINGPOOL_SIZE 4544 // XXX should be possible to make zero and disappear when codepaths not 4545 in use 4546 // to save size, for card10 this is defined as a low number (some 4547 text 4548 // properties still make use of it) 4549 // 4550 // for desktop-use this should be fully dynamic, possibly 4551 // with chained pools, gradients are stored here. 4552 #define CTX_STRINGPOOL_SIZE 1000 // 4553 #endif 4554 4555 /* whether we dither or not for gradients 4556 */ 4557 #ifndef CTX_DITHER 4558 #define CTX_DITHER 0 4559 #endif 4560 4561 /* only source-over clear and copy will work, the API still 4562 * through - but the renderer is limited, for use to measure 4563 * size and possibly in severely constrained ROMs. 4564 */ 4565 #ifndef CTX_BLENDING_AND_COMPOSITING 4566 #define CTX_BLENDING_AND_COMPOSITING 1 4567 #endif 4568 4569 /* this forces the inlining of some performance 4570 * critical paths. 4571 */ 4572 #ifndef CTX_FORCE_INLINES 4573 #define CTX_FORCE_INLINES 1 4574 #endif 4575 4576 /* create one-off inlined inner loop for normal blend mode (for floating 4577 point, 4578 * for RGBA8 manual loops overrrides 4579 */ 4580 #ifndef CTX_INLINED_NORMAL 4581 #define CTX_INLINED_NORMAL 1 4582 #endif 4583 4584 #ifndef CTX_INLINED_GRADIENTS 4585 #define CTX_INLINED_GRADIENTS 1 4586 #endif 4587 4588 #ifndef CTX_BRAILLE_TEXT 4589 #define CTX_BRAILLE_TEXT 0 4590 #endif 4591 4592 /* Build code paths for grayscale rasterization, this makes clipping 4593 * faster. 4594 */ 4595 #ifndef CTX_NATIVE_GRAYA8 4596 #define CTX_NATIVE_GRAYA8 1 4597 #endif 4598 4599 /* enable CMYK rasterization targets 4600 */ 4601 #ifndef CTX_ENABLE_CMYK 4602 #define CTX_ENABLE_CMYK 1 4603 #endif 4604 4605 /* enable color management, slightly increases CtxColor struct size, can 4606 * be disabled for microcontrollers. 4607 */ 4608 #ifndef CTX_ENABLE_CM 4609 #define CTX_ENABLE_CM 1 4610 #endif 4611 4612 #ifndef CTX_EVENTS 4613 #define CTX_EVENTS 1 4614 #endif 4615 4616 #ifndef CTX_LIMIT_FORMATS 4617 #define CTX_LIMIT_FORMATS 0 4618 #endif 4619 4620 #ifndef CTX_ENABLE_FLOAT 4621 #define CTX_ENABLE_FLOAT 0 4622 #endif 4623 4624 /* by default ctx includes all pixel formats, on microcontrollers 4625 * it can be useful to slim down code and runtime size by only 4626 * defining the used formats, set CTX_LIMIT_FORMATS to 1, and 4627 * manually add CTX_ENABLE_ flags for each of them. 4628 */ 4629 #if CTX_LIMIT_FORMATS 4630 #if CTX_NATIVE_GRAYA8 4631 #define CTX_ENABLE_GRAYA8 1 4632 #define CTX_ENABLE_GRAY8 1 4633 #endif 4634 #else 4635 4636 #define CTX_ENABLE_GRAY1 1 4637 #define CTX_ENABLE_GRAY2 1 4638 #define CTX_ENABLE_GRAY4 1 4639 #define CTX_ENABLE_GRAY8 1 4640 #define CTX_ENABLE_GRAYA8 1 4641 #define CTX_ENABLE_GRAYF 1 4642 #define CTX_ENABLE_GRAYAF 1 4643 4644 #define CTX_ENABLE_RGB8 1 4645 #define CTX_ENABLE_RGBA8 1 4646 #define CTX_ENABLE_BGRA8 1 4647 #define CTX_ENABLE_RGB332 1 4648 #define CTX_ENABLE_RGB565 1 4649 #define CTX_ENABLE_RGB565_BYTESWAPPED 1 4650 #define CTX_ENABLE_RGBAF 1 4651 #ifdef CTX_ENABLE_FLOAT 4652 #undef CTX_ENABLE_FLOAT 4653 #endif 4654 #define CTX_ENABLE_FLOAT 1 4655 #define CTX_ENABLE_YUV420 1 4656 4657 #if CTX_ENABLE_CMYK 4658 #define CTX_ENABLE_CMYK8 1 4659 #define CTX_ENABLE_CMYKA8 1 4660 #define CTX_ENABLE_CMYKAF 1 4661 #endif 4662 #endif 4663 4664 #ifndef CTX_RGB565_ALPHA 4665 #define CTX_RGB565_ALPHA 0 // when enabled pure purple is 4666 transparent, 4667 // for a ~15% overall 4668 performance hit 4669 #endif 4670 4671 #ifndef CTX_RGB332_ALPHA 4672 #define CTX_RGB332_ALPHA 0 // when enabled pure purple is 4673 transparent, 4674 // for a ~15% overall 4675 performance hit 4676 #endif 4677 4678 /* by including ctx-font-regular.h, or ctx-font-mono.h the 4679 * built-in fonts using ctx drawlist encoding is enabled 4680 */ 4681 #if CTX_FONT_regular || CTX_FONT_mono || CTX_FONT_bold \ 4682 || CTX_FONT_italic || CTX_FONT_sans || CTX_FONT_serif \ 4683 || CTX_FONT_ascii 4684 #ifndef CTX_FONT_ENGINE_CTX 4685 #define CTX_FONT_ENGINE_CTX 1 4686 #endif 4687 #endif 4688 4689 #ifndef CTX_FONT_ENGINE_CTX_FS 4690 #define CTX_FONT_ENGINE_CTX_FS 0 4691 #endif 4692 4693 /* If stb_strutype.h is included before ctx.h add integration code for 4694 runtime loading 4695 * of opentype fonts. 4696 */ 4697 #ifdef __STB_INCLUDE_STB_TRUETYPE_H__ 4698 #ifndef CTX_FONT_ENGINE_STB 4699 #define CTX_FONT_ENGINE_STB 1 4700 #endif 4701 #else 4702 #define CTX_FONT_ENGINE_STB 0 4703 #endif 4704 4705 #ifdef _BABL_H 4706 #define CTX_BABL 1 4707 #else 4708 #define CTX_BABL 0 4709 #endif 4710 4711 #ifndef CTX_ALWAYS_USE_NEAREST_FOR_SCALE1 4712 #define CTX_ALWAYS_USE_NEAREST_FOR_SCALE1 1 4713 #endif 4714 4715 /* force add format if we have shape cache */ 4716 #if CTX_SHAPE_CACHE 4717 #ifdef CTX_ENABLE_GRAY8 4718 #undef CTX_ENABLE_GRAY8 4719 #endif 4720 #define CTX_ENABLE_GRAY8 1 4721 #endif 4722 4723 /* include the bitpack packer, can be opted out of to decrease code size 4724 */ 4725 #ifndef CTX_BITPACK_PACKER 4726 #define CTX_BITPACK_PACKER 0 4727 #endif 4728 4729 /* enable RGBA8 intermediate format for 4730 *the indirectly implemented pixel-formats. 4731 */ 4732 #if CTX_ENABLE_GRAY1 | CTX_ENABLE_GRAY2 | CTX_ENABLE_GRAY4 | 4733 CTX_ENABLE_RGB565 | CTX_ENABLE_RGB565_BYTESWAPPED | CTX_ENABLE_RGB8 | 4734 CTX_ENABLE_RGB332 4735 4736 #ifdef CTX_ENABLE_RGBA8 4737 #undef CTX_ENABLE_RGBA8 4738 #endif 4739 #define CTX_ENABLE_RGBA8 1 4740 #endif 4741 4742 #ifdef CTX_ENABLE_CMYKF 4743 #ifdef CTX_ENABLE_FLOAT 4744 #undef CTX_ENABLE_FLOAT 4745 #endif 4746 #define CTX_ENABLE_FLOAT 1 4747 #endif 4748 4749 #ifdef CTX_ENABLE_GRAYF 4750 #ifdef CTX_ENABLE_FLOAT 4751 #undef CTX_ENABLE_FLOAT 4752 #endif 4753 #define CTX_ENABLE_FLOAT 1 4754 #endif 4755 4756 #ifdef CTX_ENABLE_GRAYAF 4757 #ifdef CTX_ENABLE_FLOAT 4758 #undef CTX_ENABLE_FLOAT 4759 #endif 4760 #define CTX_ENABLE_FLOAT 1 4761 #endif 4762 4763 #ifdef CTX_ENABLE_RGBAF 4764 #ifdef CTX_ENABLE_FLOAT 4765 #undef CTX_ENABLE_FLOAT 4766 #endif 4767 #define CTX_ENABLE_FLOAT 1 4768 #endif 4769 4770 #ifdef CTX_ENABLE_CMYKAF 4771 #ifdef CTX_ENABLE_FLOAT 4772 #undef CTX_ENABLE_FLOAT 4773 #endif 4774 #define CTX_ENABLE_FLOAT 1 4775 #endif 4776 4777 #ifdef CTX_ENABLE_CMYKF 4778 #ifdef CTX_ENABLE_FLOAT 4779 #undef CTX_ENABLE_FLOAT 4780 #endif 4781 #define CTX_ENABLE_FLOAT 1 4782 #endif 4783 4784 4785 /* enable cmykf which is cmyk intermediate format 4786 */ 4787 #ifdef CTX_ENABLE_CMYK8 4788 #ifdef CTX_ENABLE_CMYKF 4789 #undef CTX_ENABLE_CMYKF 4790 #endif 4791 #define CTX_ENABLE_CMYKF 1 4792 #endif 4793 #ifdef CTX_ENABLE_CMYKA8 4794 #ifdef CTX_ENABLE_CMYKF 4795 #undef CTX_ENABLE_CMYKF 4796 #endif 4797 #define CTX_ENABLE_CMYKF 1 4798 #endif 4799 4800 #ifdef CTX_ENABLE_CMYKF8 4801 #ifdef CTX_ENABLE_CMYK 4802 #undef CTX_ENABLE_CMYK 4803 #endif 4804 #define CTX_ENABLE_CMYK 1 4805 #endif 4806 4807 #define CTX_PI 3.141592653589793f 4808 #ifndef CTX_RASTERIZER_MAX_CIRCLE_SEGMENTS 4809 #define CTX_RASTERIZER_MAX_CIRCLE_SEGMENTS 400 4810 #endif 4811 4812 #ifndef CTX_MAX_FRAMEBUFFER_WIDTH 4813 #define CTX_MAX_FRAMEBUFFER_WIDTH 2560 4814 #endif 4815 4816 #ifndef CTX_MAX_FONTS 4817 #define CTX_MAX_FONTS 3 4818 #endif 4819 4820 #ifndef CTX_MAX_STATES 4821 #define CTX_MAX_STATES 10 4822 #endif 4823 4824 #ifndef CTX_MAX_EDGES 4825 #define CTX_MAX_EDGES 257 4826 #endif 4827 4828 #ifndef CTX_MAX_LINGERING_EDGES 4829 #define CTX_MAX_LINGERING_EDGES 64 4830 #endif 4831 4832 4833 #ifndef CTX_MAX_PENDING 4834 #define CTX_MAX_PENDING 128 4835 #endif 4836 4837 #ifndef CTX_MAX_TEXTURES 4838 #define CTX_MAX_TEXTURES 16 4839 #endif 4840 4841 #ifndef CTX_HASH_ROWS 4842 #define CTX_HASH_ROWS 8 4843 #endif 4844 #ifndef CTX_HASH_COLS 4845 #define CTX_HASH_COLS 8 4846 #endif 4847 4848 #ifndef CTX_MAX_THREADS 4849 #define CTX_MAX_THREADS 8 // runtime is max of cores/2 and this 4850 #endif 4851 4852 4853 4854 #define CTX_RASTERIZER_EDGE_MULTIPLIER 1024 4855 // increasing this to 2048 4856 // removes artifacts in top half of 4857 res-diagram - 4858 // but reduces maximum available 4859 buffer width 4860 #ifndef CTX_IMPLEMENTATION 4861 #define CTX_IMPLEMENTATION 0 4862 #else 4863 #undef CTX_IMPLEMENTATION 4864 #define CTX_IMPLEMENTATION 1 4865 #endif 4866 4867 4868 #ifdef CTX_RASTERIZER 4869 #if CTX_RASTERIZER==0 4870 #if CTX_SDL || CTX_FB 4871 #undef CTX_RASTERIZER 4872 #define CTX_RASTERIZER 1 4873 #endif 4874 #else 4875 #undef CTX_RASTERIZER 4876 #define CTX_RASTERIZER 1 4877 #endif 4878 #endif 4879 4880 #if CTX_RASTERIZER 4881 #ifndef CTX_COMPOSITE 4882 #define CTX_COMPOSITE 1 4883 #endif 4884 #else 4885 #ifndef CTX_COMPOSITE 4886 #define CTX_COMPOSITE 0 4887 #endif 4888 #endif 4889 4890 #ifndef CTX_GRADIENT_CACHE_ELEMENTS 4891 #define CTX_GRADIENT_CACHE_ELEMENTS 256 4892 #endif 4893 4894 #ifndef CTX_PARSER_MAX_ARGS 4895 #define CTX_PARSER_MAX_ARGS 20 4896 #endif 4897 4898 4899 #ifndef CTX_SCREENSHOT 4900 #define CTX_SCREENSHOT 0 4901 #endif 4902 4903 #ifndef CTX_ALSA_AUDIO 4904 #define CTX_ALSA_AUDIO 0 4905 #endif 4906 4907 #if NO_ALSA 4908 #undef CTX_ALSA_AUDIO 4909 #define CTX_ALSA_AUDIO 0 4910 #endif 4911 4912 #ifndef CTX_AUDIO 4913 #define CTX_AUDIO 0 4914 #endif 4915 4916 #ifndef CTX_TILED 4917 #if CTX_SDL || CTX_FB || CTX_DRM 4918 #define CTX_TILED 1 4919 #else 4920 #define CTX_TILED 0 4921 #endif 4922 #endif 4923 4924 #ifndef CTX_THREADS 4925 #if CTX_TILED 4926 #define CTX_THREADS 1 4927 #else 4928 #define CTX_THREADS 0 4929 #endif 4930 #endif 4931 4932 #if CTX_THREADS 4933 #include <pthread.h> 4934 #define mtx_lock pthread_mutex_lock 4935 #define mtx_unlock pthread_mutex_unlock 4936 #define mtx_t pthread_mutex_t 4937 #define cnd_t pthread_cond_t 4938 #define mtx_plain NULL 4939 #define mtx_init pthread_mutex_init 4940 #define cnd_init(a) pthread_cond_init(a,NULL) 4941 #define cnd_wait pthread_cond_wait 4942 #define cnd_broadcast pthread_cond_broadcast 4943 #define thrd_create(tid, tiled_render_fun, args) pthread_create(tid, NULL, 4944 tiled_render_fun, args) 4945 #define thrd_t pthread_t 4946 #endif 4947 4948 4949 /* Copyright (C) 2020 Øyvind Kolås <pippin@gimp.org> 4950 */ 4951 4952 #if CTX_FORMATTER 4953 4954 /* returns the maximum string length including terminating \0 */ 4955 int ctx_a85enc_len (int input_length); 4956 int ctx_a85enc (const void *srcp, char *dst, int count); 4957 4958 #if CTX_PARSER 4959 4960 int ctx_a85dec (const char *src, char *dst, int count); 4961 int ctx_a85len (const char *src, int count); 4962 #endif 4963 4964 #endif 4965 #ifndef __CTX_EXTRA_H 4966 #define __CTX_EXTRA_H 4967 4968 4969 #define CTX_CLAMP(val,min,max) ((val)<(min)?(min):(val)>(max)?(max):(val)) 4970 static inline int ctx_mini (int a, int b) { return (a < b) * a + (a > 4971 = b) * b; } 4972 static inline float ctx_minf (float a, float b) { return (a < b) * a + (a > 4973 = b) * b; } 4974 static inline int ctx_maxi (int a, int b) { return (a > b) * a + (a < 4975 = b) * b; } 4976 static inline float ctx_maxf (float a, float b) { return (a > b) * a + (a < 4977 = b) * b; } 4978 4979 4980 typedef enum CtxOutputmode 4981 { 4982 CTX_OUTPUT_MODE_QUARTER, 4983 CTX_OUTPUT_MODE_BRAILLE, 4984 CTX_OUTPUT_MODE_SIXELS, 4985 CTX_OUTPUT_MODE_GRAYS, 4986 CTX_OUTPUT_MODE_CTX, 4987 CTX_OUTPUT_MODE_CTX_COMPACT, 4988 CTX_OUTPUT_MODE_UI 4989 } CtxOutputmode; 4990 4991 4992 4993 4994 4995 #if CTX_FORCE_INLINES 4996 #define CTX_INLINE inline __attribute__((always_inline)) 4997 #else 4998 #define CTX_INLINE inline 4999 #endif 5000 5001 static inline float ctx_pow2 (float a) { return a * a; } 5002 #if CTX_MATH 5003 5004 static inline float 5005 ctx_fabsf (float x) 5006 { 5007 union 5008 { 5009 float f; 5010 uint32_t i; 5011 } u = { x }; 5012 u.i &= 0x7fffffff; 5013 return u.f; 5014 } 5015 5016 static inline float 5017 ctx_invsqrtf (float x) 5018 { 5019 void *foo = &x; 5020 float xhalf = 0.5f * x; 5021 int i=* (int *) foo; 5022 void *bar = &i; 5023 i = 0x5f3759df - (i >> 1); 5024 x = * (float *) bar; 5025 x *= (1.5f - xhalf * x * x); 5026 x *= (1.5f - xhalf * x * x); //repeating Newton-Raphson step for higher 5027 precision 5028 return x; 5029 } 5030 5031 static inline float 5032 ctx_invsqrtf_fast (float x) 5033 { 5034 void *foo = &x; 5035 //float xhalf = 0.5f * x; 5036 int i=* (int *) foo; 5037 void *bar = &i; 5038 i = 0x5f3759df - (i >> 1); 5039 x = * (float *) bar; 5040 //x *= (1.5f - xhalf * x * x); 5041 return x; 5042 } 5043 5044 CTX_INLINE static float ctx_sqrtf (float a) 5045 { 5046 return 1.0f/ctx_invsqrtf (a); 5047 } 5048 5049 CTX_INLINE static float ctx_sqrtf_fast (float a) 5050 { 5051 return 1.0f/ctx_invsqrtf_fast (a); 5052 } 5053 5054 CTX_INLINE static float ctx_hypotf (float a, float b) 5055 { 5056 return ctx_sqrtf (ctx_pow2 (a)+ctx_pow2 (b) ); 5057 } 5058 5059 CTX_INLINE static float ctx_hypotf_fast (float a, float b) 5060 { 5061 return ctx_sqrtf_fast (ctx_pow2 (a)+ctx_pow2 (b) ); 5062 } 5063 5064 CTX_INLINE static float 5065 ctx_sinf (float x) 5066 { 5067 if (x < -CTX_PI * 2) 5068 { 5069 x = -x; 5070 long ix = x / (CTX_PI * 2); 5071 x = x - ix * CTX_PI * 2; 5072 x = -x; 5073 } 5074 if (x < -CTX_PI * 1000) 5075 { 5076 x = -0.5; 5077 } 5078 if (x > CTX_PI * 1000) 5079 { 5080 // really large numbers tend to cause practically inifinite 5081 // loops since the > CTX_PI * 2 seemingly fails 5082 x = 0.5; 5083 } 5084 if (x > CTX_PI * 2) 5085 { 5086 long ix = x / (CTX_PI * 2); 5087 x = x - (ix * CTX_PI * 2); 5088 } 5089 while (x < -CTX_PI) 5090 { x += CTX_PI * 2; } 5091 while (x > CTX_PI) 5092 { x -= CTX_PI * 2; } 5093 5094 /* source : http://mooooo.ooo/chebyshev-sine-approximation/ */ 5095 float coeffs[]= 5096 { 5097 -0.10132118f, // x 5098 0.0066208798f, // x^3 5099 -0.00017350505f, // x^5 5100 0.0000025222919f, // x^7 5101 -0.000000023317787f, // x^9 5102 0.00000000013291342f 5103 }; // x^11 5104 float x2 = x*x; 5105 float p11 = coeffs[5]; 5106 float p9 = p11*x2 + coeffs[4]; 5107 float p7 = p9*x2 + coeffs[3]; 5108 float p5 = p7*x2 + coeffs[2]; 5109 float p3 = p5*x2 + coeffs[1]; 5110 float p1 = p3*x2 + coeffs[0]; 5111 return (x - CTX_PI + 0.00000008742278f) * 5112 (x + CTX_PI - 0.00000008742278f) * p1 * x; 5113 } 5114 5115 static inline float ctx_atan2f (float y, float x) 5116 { 5117 float atan, z; 5118 if ( x == 0.0f ) 5119 { 5120 if ( y > 0.0f ) 5121 { return CTX_PI/2; } 5122 if ( y == 0.0f ) 5123 { return 0.0f; } 5124 return -CTX_PI/2; 5125 } 5126 z = y/x; 5127 if ( ctx_fabsf ( z ) < 1.0f ) 5128 { 5129 atan = z/ (1.0f + 0.28f*z*z); 5130 if (x < 0.0f) 5131 { 5132 if ( y < 0.0f ) 5133 { return atan - CTX_PI; } 5134 return atan + CTX_PI; 5135 } 5136 } 5137 else 5138 { 5139 atan = CTX_PI/2 - z/ (z*z + 0.28f); 5140 if ( y < 0.0f ) { return atan - CTX_PI; } 5141 } 5142 return atan; 5143 } 5144 5145 5146 static inline float ctx_atanf (float a) 5147 { 5148 return ctx_atan2f ( (a), 1.0f); 5149 } 5150 5151 static inline float ctx_asinf (float x) 5152 { 5153 return ctx_atanf ( (x) * (ctx_invsqrtf (1.0f-ctx_pow2 (x) ) ) ); 5154 } 5155 5156 static inline float ctx_acosf (float x) 5157 { 5158 return ctx_atanf ( (ctx_sqrtf (1.0f-ctx_pow2 (x) ) / (x) ) ); 5159 } 5160 5161 CTX_INLINE static float ctx_cosf (float a) 5162 { 5163 return ctx_sinf ( (a) + CTX_PI/2.0f); 5164 } 5165 5166 static inline float ctx_tanf (float a) 5167 { 5168 return (ctx_cosf (a) /ctx_sinf (a) ); 5169 } 5170 static inline float 5171 ctx_floorf (float x) 5172 { 5173 return (int)x; // XXX 5174 } 5175 static inline float 5176 ctx_expf (float x) 5177 { 5178 union { uint32_t i; float f; } v = 5179 { (uint32_t)( (1 << 23) * (x + 183.1395965f)) }; 5180 return v.f; 5181 } 5182 5183 /* define more trig based on having sqrt, sin and atan2 */ 5184 5185 #else 5186 #if !__COSMOPOLITAN__ 5187 #include <math.h> 5188 #endif 5189 static inline float ctx_fabsf (float x) { return fabsf (x); } 5190 static inline float ctx_floorf (float x) { return floorf (x); } 5191 static inline float ctx_sinf (float x) { return sinf (x); } 5192 static inline float ctx_atan2f (float y, float x) { return atan2f (y, x); } 5193 static inline float ctx_hypotf (float a, float b) { return hypotf (a, b); } 5194 static inline float ctx_acosf (float a) { return acosf (a); } 5195 static inline float ctx_cosf (float a) { return cosf (a); } 5196 static inline float ctx_tanf (float a) { return tanf (a); } 5197 static inline float ctx_expf (float p) { return expf (p); } 5198 static inline float ctx_sqrtf (float a) { return sqrtf (a); } 5199 #endif 5200 5201 static inline float _ctx_parse_float (const char *str, char **endptr) 5202 { 5203 return strtod (str, endptr); /* XXX: , vs . problem in some locales */ 5204 } 5205 5206 const char *ctx_get_string (Ctx *ctx, uint64_t hash); 5207 void ctx_set_string (Ctx *ctx, uint64_t hash, const char *value); 5208 typedef struct _CtxColor CtxColor; 5209 5210 void 5211 ctx_matrix_translate (CtxMatrix *matrix, float x, float y); 5212 5213 5214 void ctx_get_matrix (Ctx *ctx, CtxMatrix *matrix); 5215 void ctx_set_matrix (Ctx *ctx, CtxMatrix *matrix); 5216 int _ctx_is_rasterizer (Ctx *ctx); 5217 5218 int ctx_color (Ctx *ctx, const char *string); 5219 typedef struct _CtxState CtxState; 5220 CtxColor *ctx_color_new (); 5221 CtxState *ctx_get_state (Ctx *ctx); 5222 void ctx_color_get_rgba (CtxState *state, CtxColor *color, float *out); 5223 void ctx_color_set_rgba (CtxState *state, CtxColor *color, float r, float g, 5224 float b, float a); 5225 void ctx_color_free (CtxColor *color); 5226 void ctx_set_color (Ctx *ctx, uint64_t hash, CtxColor *color); 5227 int ctx_get_color (Ctx *ctx, uint64_t hash, CtxColor *color); 5228 int ctx_color_set_from_string (Ctx *ctx, CtxColor *color, const char 5229 *string); 5230 5231 int ctx_color_is_transparent (CtxColor *color); 5232 int ctx_utf8_len (const unsigned char first_byte); 5233 5234 void ctx_user_to_device (Ctx *ctx, float *x, float *y); 5235 void ctx_user_to_device_distance (Ctx *ctx, float *x, float *y); 5236 const char *ctx_utf8_skip (const char *s, int utf8_length); 5237 int ctx_is_set_now (Ctx *ctx, uint64_t hash); 5238 void ctx_set_size (Ctx *ctx, int width, int height); 5239 5240 static inline float ctx_matrix_get_scale (CtxMatrix *matrix) 5241 { 5242 return ctx_maxf (ctx_maxf (ctx_fabsf (matrix->m[0][0]), 5243 ctx_fabsf (matrix->m[0][1]) ), 5244 ctx_maxf (ctx_fabsf (matrix->m[1][0]), 5245 ctx_fabsf (matrix->m[1][1]) ) ); 5246 } 5247 5248 #if CTX_GET_CONTENTS 5249 int 5250 _ctx_file_get_contents (const char *path, 5251 unsigned char **contents, 5252 long *length); 5253 #endif 5254 5255 #if CTX_FONTS_FROM_FILE 5256 int ctx_load_font_ttf_file (const char *name, const char *path); 5257 #endif 5258 5259 #if CTX_BABL 5260 void ctx_rasterizer_colorspace_babl (CtxState *state, 5261 CtxColorSpace space_slot, 5262 const Babl *space); 5263 #endif 5264 void ctx_rasterizer_colorspace_icc (CtxState *state, 5265 CtxColorSpace space_slot, 5266 char *icc_data, 5267 int icc_length); 5268 5269 5270 CtxBuffer *ctx_buffer_new_bare (void); 5271 5272 void ctx_buffer_set_data (CtxBuffer *buffer, 5273 void *data, int width, int height, 5274 int stride, 5275 CtxPixelFormat pixel_format, 5276 void (*freefunc) (void *pixels, void *user_data), 5277 void *user_data); 5278 5279 int _ctx_set_frame (Ctx *ctx, int frame); 5280 int _ctx_frame (Ctx *ctx); 5281 5282 5283 void ctx_exit (Ctx *ctx); 5284 void ctx_list_backends(void); 5285 int ctx_pixel_format_ebpp (CtxPixelFormat format); 5286 5287 #endif 5288 #ifndef __CTX_CONSTANTS 5289 #define __CTX_CONSTANTS 5290 5291 #define TOKENHASH(a) ((uint64_t)a) 5292 5293 #define CTX_strokeSource TOKENHASH(3061861651908008) 5294 #define CTX_add_stop TOKENHASH(1274978316678) 5295 #define CTX_addStop TOKENHASH(40799943078278) 5296 #define CTX_alphabetic TOKENHASH(2629359926678406) 5297 #define CTX_arc TOKENHASH(11526) 5298 #define CTX_arc_to TOKENHASH(1187065094) 5299 #define CTX_arcTo TOKENHASH(38558051590) 5300 #define CTX_begin_path TOKENHASH(3004110681622984) 5301 #define CTX_beginPath TOKENHASH(8437143659599196) 5302 #define CTX_bevel TOKENHASH(29868488) 5303 #define CTX_bottom TOKENHASH(1043772488) 5304 #define CTX_cap TOKENHASH(37066) 5305 #define CTX_center TOKENHASH(1358332362) 5306 #define CTX_clear TOKENHASH(42154890) 5307 #define CTX_color TOKENHASH(43086922) 5308 #define CTX_copy TOKENHASH(1807434) 5309 #define CTX_clip TOKENHASH(1203082) 5310 #define CTX_close_path TOKENHASH(3004110663420810) 5311 #define CTX_closePath TOKENHASH(8437144279135038) 5312 #define CTX_cmyka TOKENHASH(7199690) 5313 #define CTX_cmyk TOKENHASH(908234) 5314 #define CTX_cmykaS TOKENHASH(36313095114) 5315 #define CTX_cmykS TOKENHASH(1135467466) 5316 #define CTX_color TOKENHASH(43086922) 5317 #define CTX_blending TOKENHASH(653586873224) 5318 #define CTX_blend TOKENHASH(13646728) 5319 #define CTX_blending_mode TOKENHASH(8147360531130856) 5320 #define CTX_blendingMode TOKENHASH(7483585768187540) 5321 #define CTX_blend_mode TOKENHASH(2758775686577032) 5322 #define CTX_blendMode TOKENHASH(7773213171090182) 5323 #define CTX_composite TOKENHASH(16930059746378) 5324 #define CTX_compositing_mode TOKENHASH(2417816728103524) 5325 #define CTX_compositingMode TOKENHASH(2807194446992106) 5326 #define CTX_curve_to TOKENHASH(1215559149002) 5327 #define CTX_curveTo TOKENHASH(39483449320906) 5328 #define CTX_darken TOKENHASH(1089315020) 5329 #define CTX_defineGlyph TOKENHASH(2497926167421194) 5330 #define CTX_defineTexture TOKENHASH(2623744577477404) 5331 #define CTX_kerningPair TOKENHASH(6964644556489058) 5332 #define CTX_destinationIn TOKENHASH(8153299143600102) 5333 #define CTX_destination_in TOKENHASH(3824201982576824) 5334 #define CTX_destinationAtop TOKENHASH(8185118415574560) 5335 #define CTX_destination_atop TOKENHASH(7742210324901698) 5336 #define CTX_destinationOver TOKENHASH(3261713333438500) 5337 #define CTX_destination_over TOKENHASH(7742210324728474) 5338 #define CTX_destinationOut TOKENHASH(7742210322269456) 5339 #define CTX_destination_out TOKENHASH(8153299143489102) 5340 #define CTX_difference TOKENHASH(2756492040618700) 5341 #define CTX_done TOKENHASH(492620) 5342 #define CTX_drgba TOKENHASH(6573324) 5343 #define CTX_drgb TOKENHASH(281868) 5344 #define CTX_drgbaS TOKENHASH(36312468748) 5345 #define CTX_drgbS TOKENHASH(1134841100) 5346 #define CTX_end TOKENHASH(13326) 5347 #define CTX_endfun TOKENHASH(1122513934) 5348 #define CTX_end_group TOKENHASH(41200834917390) 5349 #define CTX_endGroup TOKENHASH(3570227948106766) 5350 #define CTX_even_odd TOKENHASH(426345774606) 5351 #define CTX_evenOdd TOKENHASH(13671748091406) 5352 #define CTX_exit TOKENHASH(1465998) 5353 #define CTX_fill TOKENHASH(946896) 5354 #define CTX_fill_rule TOKENHASH(16405972808400) 5355 #define CTX_fillRule TOKENHASH(2776813389378256) 5356 #define CTX_flush TOKENHASH(22395792) 5357 #define CTX_font TOKENHASH(1475664) 5358 #define CTX_font_size TOKENHASH(17342343316560) 5359 #define CTX_setFontSize TOKENHASH(8657699789799734) 5360 #define CTX_fontSize TOKENHASH(2806775148872784) 5361 #define CTX_function TOKENHASH(1136803546576) 5362 #define CTX_getkey TOKENHASH(1827516882) 5363 #define CTX_global_alpha TOKENHASH(6945103263242432) 5364 #define CTX_globalAlpha TOKENHASH(2684560928159160) 5365 #define CTX_glyph TOKENHASH(22207378) 5366 #define CTX_gradient_add_stop TOKENHASH(7829524561074416) 5367 #define CTX_gradientAddStop TOKENHASH(8126442749593072) 5368 #define CTX_graya TOKENHASH(8068370) 5369 #define CTX_gray TOKENHASH(1776914) 5370 #define CTX_grayaS TOKENHASH(36313963794) 5371 #define CTX_grayS TOKENHASH(1136336146) 5372 #define CTX_hanging TOKENHASH(20424786132) 5373 #define CTX_height TOKENHASH(1497979348) 5374 #define CTX_hor_line_to TOKENHASH(8345271542735158) 5375 #define CTX_horLineTo TOKENHASH(3629696407754856) 5376 #define CTX_hue TOKENHASH(15828) 5377 #define CTX_identity TOKENHASH(1903455910294) 5378 #define CTX_ideographic TOKENHASH(4370819675496700) 5379 #define CTX_imageSmoothing TOKENHASH(4268778175825416) 5380 #define CTX_join TOKENHASH(1072216) 5381 #define CTX_laba TOKENHASH(205020) 5382 #define CTX_lab TOKENHASH(8412) 5383 #define CTX_lcha TOKENHASH(217436) 5384 #define CTX_lch TOKENHASH(20828) 5385 #define CTX_labaS TOKENHASH(1134764252) 5386 #define CTX_labS TOKENHASH(35463388) 5387 #define CTX_lchaS TOKENHASH(1134776668) 5388 #define CTX_lchS TOKENHASH(35475804) 5389 #define CTX_left TOKENHASH(1458652) 5390 #define CTX_lighter TOKENHASH(43466246876) 5391 #define CTX_lighten TOKENHASH(34876312284) 5392 #define CTX_linear_gradient TOKENHASH(7801595375834212) 5393 #define CTX_linearGradient TOKENHASH(4439260636789186) 5394 #define CTX_line_cap TOKENHASH(1243731165916) 5395 #define CTX_lineCap TOKENHASH(3436510399409980) 5396 #define CTX_setLineCap TOKENHASH(7897176123029482) 5397 #define CTX_line_height TOKENHASH(3300223516389168) 5398 #define CTX_line_join TOKENHASH(35977601450716) 5399 #define CTX_lineJoin TOKENHASH(3403122163024604) 5400 #define CTX_setLineJoin TOKENHASH(2768281536656332) 5401 #define CTX_line_spacing TOKENHASH(2519451230887150) 5402 #define CTX_line_to TOKENHASH(37986206428) 5403 #define CTX_lineTo TOKENHASH(1233857774300) 5404 #define CTX_lineDash TOKENHASH(3001937455186652) 5405 #define CTX_lineDashOffset TOKENHASH(3704120356324362) 5406 #define CTX_line_width TOKENHASH(3004303386575580) 5407 #define CTX_lineWidth TOKENHASH(8241159254028040) 5408 #define CTX_setLineWidth TOKENHASH(8037913618228476) 5409 #define CTX_view_box TOKENHASH(1823485803248) 5410 #define CTX_viewBox TOKENHASH(3915860941641152) 5411 #define CTX_middle TOKENHASH(499528414) 5412 #define CTX_miter TOKENHASH(42447582) 5413 #define CTX_miter_limit TOKENHASH(4281255327472850) 5414 #define CTX_miterLimit TOKENHASH(7937453649653124) 5415 #define CTX_move_to TOKENHASH(37986223198) 5416 #define CTX_moveTo TOKENHASH(1233857791070) 5417 #define CTX_multiply TOKENHASH(1886723143134) 5418 #define CTX_new_page TOKENHASH(500602882528) 5419 #define CTX_newPage TOKENHASH(16020123011552) 5420 #define CTX_new_path TOKENHASH(734678600160) 5421 #define CTX_newPath TOKENHASH(23510545975776) 5422 #define CTX_new_state TOKENHASH(16912954280416) 5423 #define CTX_none TOKENHASH(492640) 5424 #define CTX_nonzero TOKENHASH(37865948256) 5425 #define CTX_non_zero TOKENHASH(1211709359200) 5426 #define CTX_normal TOKENHASH(946840672) 5427 #define CTX_quad_to TOKENHASH(37986115046) 5428 #define CTX_quadTo TOKENHASH(1233857682918) 5429 #define CTX_radial_gradient TOKENHASH(8267515704460560) 5430 #define CTX_radialGradient TOKENHASH(4399889250822134) 5431 #define CTX_rectangle TOKENHASH(16375644301800) 5432 #define CTX_rect TOKENHASH(1452520) 5433 #define CTX_rel_arc_to TOKENHASH(3496527781786088) 5434 #define CTX_relArcTo TOKENHASH(3209152175601038) 5435 #define CTX_rel_curve_to TOKENHASH(4439651822639910) 5436 #define CTX_relCurveTo TOKENHASH(7294415873689320) 5437 #define CTX_rel_hor_line_to TOKENHASH(7051067105640810) 5438 #define CTX_relHorLineTo TOKENHASH(8737419863647946) 5439 #define CTX_relVerLineTo TOKENHASH(8737441317512906) 5440 #define CTX_rel_line_to TOKENHASH(8345271542378314) 5441 #define CTX_relLineTo TOKENHASH(3629696197927444) 5442 #define CTX_rel_move_to TOKENHASH(8344984486309706) 5443 #define CTX_relMoveTo TOKENHASH(3571677202293268) 5444 #define CTX_rel_quad_to TOKENHASH(8343627754794826) 5445 #define CTX_relQuadTo TOKENHASH(7894357900599828) 5446 #define CTX_rel_smoothq_to TOKENHASH(7340038162167138) 5447 #define CTX_relSmoothqTo TOKENHASH(3188040406230844) 5448 #define CTX_rel_smooth_to TOKENHASH(8144941131301668) 5449 #define CTX_relSmoothTo TOKENHASH(8947422784198618) 5450 #define C