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