QRScanner/mobile/jni/thirdparty/freetype/src/cff/cffdrivr.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  cffdrivr.c                                                             */
   4 /*                                                                         */
   5 /*    OpenType font driver implementation (body).                          */
   6 /*                                                                         */
   7 /*  Copyright 1996-2012 by                                                 */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include FT_FREETYPE_H
  21 #include FT_INTERNAL_DEBUG_H
  22 #include FT_INTERNAL_STREAM_H
  23 #include FT_INTERNAL_SFNT_H
  24 #include FT_SERVICE_CID_H
  25 #include FT_SERVICE_POSTSCRIPT_INFO_H
  26 #include FT_SERVICE_POSTSCRIPT_NAME_H
  27 #include FT_SERVICE_TT_CMAP_H
  28
  29 #include "cffdrivr.h"
  30 #include "cffgload.h"
  31 #include "cffload.h"
  32 #include "cffcmap.h"
  33 #include "cffparse.h"
  34
  35 #include "cfferrs.h"
  36 #include "cffpic.h"
  37
  38 #include FT_SERVICE_XFREE86_NAME_H
  39 #include FT_SERVICE_GLYPH_DICT_H
  40
  41
  42   /*************************************************************************/
  43   /*                                                                       */
  44   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  45   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  46   /* messages during execution.                                            */
  47   /*                                                                       */
  48 #undef  FT_COMPONENT
  49 #define FT_COMPONENT  trace_cffdriver
  50
  51
  52   /*************************************************************************/
  53   /*************************************************************************/
  54   /*************************************************************************/
  55   /****                                                                 ****/
  56   /****                                                                 ****/
  57   /****                          F A C E S                              ****/
  58   /****                                                                 ****/
  59   /****                                                                 ****/
  60   /*************************************************************************/
  61   /*************************************************************************/
  62   /*************************************************************************/
  63
  64
  65 #undef  PAIR_TAG
  66 #define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \
  67                                      (FT_ULong)right        )
  68
  69
  70   /*************************************************************************/
  71   /*                                                                       */
  72   /* <Function>                                                            */
  73   /*    cff_get_kerning                                                    */
  74   /*                                                                       */
  75   /* <Description>                                                         */
  76   /*    A driver method used to return the kerning vector between two      */
  77   /*    glyphs of the same face.                                           */
  78   /*                                                                       */
  79   /* <Input>                                                               */
  80   /*    face        :: A handle to the source face object.                 */
  81   /*                                                                       */
  82   /*    left_glyph  :: The index of the left glyph in the kern pair.       */
  83   /*                                                                       */
  84   /*    right_glyph :: The index of the right glyph in the kern pair.      */
  85   /*                                                                       */
  86   /* <Output>                                                              */
  87   /*    kerning     :: The kerning vector.  This is in font units for      */
  88   /*                   scalable formats, and in pixels for fixed-sizes     */
  89   /*                   formats.                                            */
  90   /*                                                                       */
  91   /* <Return>                                                              */
  92   /*    FreeType error code.  0 means success.                             */
  93   /*                                                                       */
  94   /* <Note>                                                                */
  95   /*    Only horizontal layouts (left-to-right & right-to-left) are        */
  96   /*    supported by this function.  Other layouts, or more sophisticated  */
  97   /*    kernings, are out of scope of this method (the basic driver        */
  98   /*    interface is meant to be simple).                                  */
  99   /*                                                                       */
 100   /*    They can be implemented by format-specific interfaces.             */
 101   /*                                                                       */
 102   FT_CALLBACK_DEF( FT_Error )
 103   cff_get_kerning( FT_Face     ttface,          /* TT_Face */
 104                    FT_UInt     left_glyph,
 105                    FT_UInt     right_glyph,
 106                    FT_Vector*  kerning )
 107   {
 108     TT_Face       face = (TT_Face)ttface;
 109     SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
 110
 111
 112     kerning->x = 0;
 113     kerning->y = 0;
 114
 115     if ( sfnt )
 116       kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );
 117
 118     return CFF_Err_Ok;
 119   }
 120
 121
 122 #undef PAIR_TAG
 123
 124
 125   /*************************************************************************/
 126   /*                                                                       */
 127   /* <Function>                                                            */
 128   /*    cff_glyph_load                                                     */
 129   /*                                                                       */
 130   /* <Description>                                                         */
 131   /*    A driver method used to load a glyph within a given glyph slot.    */
 132   /*                                                                       */
 133   /* <Input>                                                               */
 134   /*    slot        :: A handle to the target slot object where the glyph  */
 135   /*                   will be loaded.                                     */
 136   /*                                                                       */
 137   /*    size        :: A handle to the source face size at which the glyph */
 138   /*                   must be scaled, loaded, etc.                        */
 139   /*                                                                       */
 140   /*    glyph_index :: The index of the glyph in the font file.            */
 141   /*                                                                       */
 142   /*    load_flags  :: A flag indicating what to load for this glyph.  The */
 143   /*                   FT_LOAD_??? constants can be used to control the    */
 144   /*                   glyph loading process (e.g., whether the outline    */
 145   /*                   should be scaled, whether to load bitmaps or not,   */
 146   /*                   whether to hint the outline, etc).                  */
 147   /*                                                                       */
 148   /* <Return>                                                              */
 149   /*    FreeType error code.  0 means success.                             */
 150   /*                                                                       */
 151   FT_CALLBACK_DEF( FT_Error )
 152   cff_glyph_load( FT_GlyphSlot  cffslot,      /* CFF_GlyphSlot */
 153                   FT_Size       cffsize,      /* CFF_Size      */
 154                   FT_UInt       glyph_index,
 155                   FT_Int32      load_flags )
 156   {
 157     FT_Error       error;
 158     CFF_GlyphSlot  slot = (CFF_GlyphSlot)cffslot;
 159     CFF_Size       size = (CFF_Size)cffsize;
 160
 161
 162     if ( !slot )
 163       return CFF_Err_Invalid_Slot_Handle;
 164
 165     /* check whether we want a scaled outline or bitmap */
 166     if ( !size )
 167       load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
 168
 169     /* reset the size object if necessary */
 170     if ( load_flags & FT_LOAD_NO_SCALE )
 171       size = NULL;
 172
 173     if ( size )
 174     {
 175       /* these two objects must have the same parent */
 176       if ( cffsize->face != cffslot->face )
 177         return CFF_Err_Invalid_Face_Handle;
 178     }
 179
 180     /* now load the glyph outline if necessary */
 181     error = cff_slot_load( slot, size, glyph_index, load_flags );
 182
 183     /* force drop-out mode to 2 - irrelevant now */
 184     /* slot->outline.dropout_mode = 2; */
 185
 186     return error;
 187   }
 188
 189
 190   FT_CALLBACK_DEF( FT_Error )
 191   cff_get_advances( FT_Face    face,
 192                     FT_UInt    start,
 193                     FT_UInt    count,
 194                     FT_Int32   flags,
 195                     FT_Fixed*  advances )
 196   {
 197     FT_UInt       nn;
 198     FT_Error      error = CFF_Err_Ok;
 199     FT_GlyphSlot  slot  = face->glyph;
 200
 201
 202     flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
 203
 204     for ( nn = 0; nn < count; nn++ )
 205     {
 206       error = cff_glyph_load( slot, face->size, start + nn, flags );
 207       if ( error )
 208         break;
 209
 210       advances[nn] = ( flags & FT_LOAD_VERTICAL_LAYOUT )
 211                      ? slot->linearVertAdvance
 212                      : slot->linearHoriAdvance;
 213     }
 214
 215     return error;
 216   }
 217
 218
 219   /*
 220    *  GLYPH DICT SERVICE
 221    *
 222    */
 223
 224   static FT_Error
 225   cff_get_glyph_name( CFF_Face    face,
 226                       FT_UInt     glyph_index,
 227                       FT_Pointer  buffer,
 228                       FT_UInt     buffer_max )
 229   {
 230     CFF_Font    font   = (CFF_Font)face->extra.data;
 231     FT_String*  gname;
 232     FT_UShort   sid;
 233     FT_Error    error;
 234
 235
 236     if ( !font->psnames )
 237     {
 238       FT_ERROR(( "cff_get_glyph_name:"
 239                  " cannot get glyph name from CFF & CEF fonts\n"
 240                  "                   "
 241                  " without the `PSNames' module\n" ));
 242       error = CFF_Err_Missing_Module;
 243       goto Exit;
 244     }
 245
 246     /* first, locate the sid in the charset table */
 247     sid = font->charset.sids[glyph_index];
 248
 249     /* now, lookup the name itself */
 250     gname = cff_index_get_sid_string( font, sid );
 251
 252     if ( gname )
 253       FT_STRCPYN( buffer, gname, buffer_max );
 254
 255     error = CFF_Err_Ok;
 256
 257   Exit:
 258     return error;
 259   }
 260
 261
 262   static FT_UInt
 263   cff_get_name_index( CFF_Face    face,
 264                       FT_String*  glyph_name )
 265   {
 266     CFF_Font            cff;
 267     CFF_Charset         charset;
 268     FT_Service_PsCMaps  psnames;
 269     FT_String*          name;
 270     FT_UShort           sid;
 271     FT_UInt             i;
 272
 273
 274     cff     = (CFF_FontRec *)face->extra.data;
 275     charset = &cff->charset;
 276
 277     FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
 278     if ( !psnames )
 279       return 0;
 280
 281     for ( i = 0; i < cff->num_glyphs; i++ )
 282     {
 283       sid = charset->sids[i];
 284
 285       if ( sid > 390 )
 286         name = cff_index_get_string( cff, sid - 391 );
 287       else
 288         name = (FT_String *)psnames->adobe_std_strings( sid );
 289
 290       if ( !name )
 291         continue;
 292
 293       if ( !ft_strcmp( glyph_name, name ) )
 294         return i;
 295     }
 296
 297     return 0;
 298   }
 299
 300
 301   FT_DEFINE_SERVICE_GLYPHDICTREC(cff_service_glyph_dict,
 302     (FT_GlyphDict_GetNameFunc)  cff_get_glyph_name,
 303     (FT_GlyphDict_NameIndexFunc)cff_get_name_index
 304   )
 305
 306
 307   /*
 308    *  POSTSCRIPT INFO SERVICE
 309    *
 310    */
 311
 312   static FT_Int
 313   cff_ps_has_glyph_names( FT_Face  face )
 314   {
 315     return ( face->face_flags & FT_FACE_FLAG_GLYPH_NAMES ) > 0;
 316   }
 317
 318
 319   static FT_Error
 320   cff_ps_get_font_info( CFF_Face         face,
 321                         PS_FontInfoRec*  afont_info )
 322   {
 323     CFF_Font  cff   = (CFF_Font)face->extra.data;
 324     FT_Error  error = CFF_Err_Ok;
 325
 326
 327     if ( cff && cff->font_info == NULL )
 328     {
 329       CFF_FontRecDict  dict   = &cff->top_font.font_dict;
 330       PS_FontInfoRec  *font_info = NULL;
 331       FT_Memory        memory = face->root.memory;
 332
 333
 334       if ( FT_ALLOC( font_info, sizeof ( *font_info ) ) )
 335         goto Fail;
 336
 337       font_info->version     = cff_index_get_sid_string( cff,
 338                                                          dict->version );
 339       font_info->notice      = cff_index_get_sid_string( cff,
 340                                                          dict->notice );
 341       font_info->full_name   = cff_index_get_sid_string( cff,
 342                                                          dict->full_name );
 343       font_info->family_name = cff_index_get_sid_string( cff,
 344                                                          dict->family_name );
 345       font_info->weight      = cff_index_get_sid_string( cff,
 346                                                          dict->weight );
 347       font_info->italic_angle        = dict->italic_angle;
 348       font_info->is_fixed_pitch      = dict->is_fixed_pitch;
 349       font_info->underline_position  = (FT_Short)dict->underline_position;
 350       font_info->underline_thickness = (FT_Short)dict->underline_thickness;
 351
 352       cff->font_info = font_info;
 353     }
 354
 355     if ( cff )
 356       *afont_info = *cff->font_info;
 357
 358   Fail:
 359     return error;
 360   }
 361
 362
 363   FT_DEFINE_SERVICE_PSINFOREC(cff_service_ps_info,
 364     (PS_GetFontInfoFunc)   cff_ps_get_font_info,
 365     (PS_GetFontExtraFunc)  NULL,
 366     (PS_HasGlyphNamesFunc) cff_ps_has_glyph_names,
 367     (PS_GetFontPrivateFunc)NULL,        /* unsupported with CFF fonts */
 368     (PS_GetFontValueFunc)  NULL         /* not implemented            */
 369   )
 370
 371
 372   /*
 373    *  POSTSCRIPT NAME SERVICE
 374    *
 375    */
 376
 377   static const char*
 378   cff_get_ps_name( CFF_Face  face )
 379   {
 380     CFF_Font  cff = (CFF_Font)face->extra.data;
 381
 382
 383     return (const char*)cff->font_name;
 384   }
 385
 386
 387   FT_DEFINE_SERVICE_PSFONTNAMEREC(cff_service_ps_name,
 388     (FT_PsName_GetFunc)cff_get_ps_name
 389   )
 390
 391
 392   /*
 393    * TT CMAP INFO
 394    *
 395    * If the charmap is a synthetic Unicode encoding cmap or
 396    * a Type 1 standard (or expert) encoding cmap, hide TT CMAP INFO
 397    * service defined in SFNT module.
 398    *
 399    * Otherwise call the service function in the sfnt module.
 400    *
 401    */
 402   static FT_Error
 403   cff_get_cmap_info( FT_CharMap    charmap,
 404                      TT_CMapInfo  *cmap_info )
 405   {
 406     FT_CMap   cmap  = FT_CMAP( charmap );
 407     FT_Error  error = CFF_Err_Ok;
 408     FT_Face    face    = FT_CMAP_FACE( cmap );
 409     FT_Library library = FT_FACE_LIBRARY( face );
 410
 411
 412     cmap_info->language = 0;
 413     cmap_info->format   = 0;
 414
 415     if ( cmap->clazz != &CFF_CMAP_ENCODING_CLASS_REC_GET &&
 416          cmap->clazz != &CFF_CMAP_UNICODE_CLASS_REC_GET  )
 417     {
 418       FT_Module           sfnt    = FT_Get_Module( library, "sfnt" );
 419       FT_Service_TTCMaps  service =
 420         (FT_Service_TTCMaps)ft_module_get_service( sfnt,
 421                                                    FT_SERVICE_ID_TT_CMAP );
 422
 423
 424       if ( service && service->get_cmap_info )
 425         error = service->get_cmap_info( charmap, cmap_info );
 426     }
 427
 428     return error;
 429   }
 430
 431
 432   FT_DEFINE_SERVICE_TTCMAPSREC(cff_service_get_cmap_info,
 433     (TT_CMap_Info_GetFunc)cff_get_cmap_info
 434   )
 435
 436
 437   /*
 438    *  CID INFO SERVICE
 439    *
 440    */
 441   static FT_Error
 442   cff_get_ros( CFF_Face      face,
 443                const char*  *registry,
 444                const char*  *ordering,
 445                FT_Int       *supplement )
 446   {
 447     FT_Error  error = CFF_Err_Ok;
 448     CFF_Font  cff   = (CFF_Font)face->extra.data;
 449
 450
 451     if ( cff )
 452     {
 453       CFF_FontRecDict  dict = &cff->top_font.font_dict;
 454
 455
 456       if ( dict->cid_registry == 0xFFFFU )
 457       {
 458         error = CFF_Err_Invalid_Argument;
 459         goto Fail;
 460       }
 461
 462       if ( registry )
 463       {
 464         if ( cff->registry == NULL )
 465           cff->registry = cff_index_get_sid_string( cff,
 466                                                     dict->cid_registry );
 467         *registry = cff->registry;
 468       }
 469
 470       if ( ordering )
 471       {
 472         if ( cff->ordering == NULL )
 473           cff->ordering = cff_index_get_sid_string( cff,
 474                                                     dict->cid_ordering );
 475         *ordering = cff->ordering;
 476       }
 477
 478       /*
 479        * XXX: According to Adobe TechNote #5176, the supplement in CFF
 480        *      can be a real number. We truncate it to fit public API
 481        *      since freetype-2.3.6.
 482        */
 483       if ( supplement )
 484       {
 485         if ( dict->cid_supplement < FT_INT_MIN ||
 486              dict->cid_supplement > FT_INT_MAX )
 487           FT_TRACE1(( "cff_get_ros: too large supplement %d is truncated\n",
 488                       dict->cid_supplement ));
 489         *supplement = (FT_Int)dict->cid_supplement;
 490       }
 491     }
 492
 493   Fail:
 494     return error;
 495   }
 496
 497
 498   static FT_Error
 499   cff_get_is_cid( CFF_Face  face,
 500                   FT_Bool  *is_cid )
 501   {
 502     FT_Error  error = CFF_Err_Ok;
 503     CFF_Font  cff   = (CFF_Font)face->extra.data;
 504
 505
 506     *is_cid = 0;
 507
 508     if ( cff )
 509     {
 510       CFF_FontRecDict  dict = &cff->top_font.font_dict;
 511
 512
 513       if ( dict->cid_registry != 0xFFFFU )
 514         *is_cid = 1;
 515     }
 516
 517     return error;
 518   }
 519
 520
 521   static FT_Error
 522   cff_get_cid_from_glyph_index( CFF_Face  face,
 523                                 FT_UInt   glyph_index,
 524                                 FT_UInt  *cid )
 525   {
 526     FT_Error  error = CFF_Err_Ok;
 527     CFF_Font  cff;
 528
 529
 530     cff = (CFF_Font)face->extra.data;
 531
 532     if ( cff )
 533     {
 534       FT_UInt          c;
 535       CFF_FontRecDict  dict = &cff->top_font.font_dict;
 536
 537
 538       if ( dict->cid_registry == 0xFFFFU )
 539       {
 540         error = CFF_Err_Invalid_Argument;
 541         goto Fail;
 542       }
 543
 544       if ( glyph_index > cff->num_glyphs )
 545       {
 546         error = CFF_Err_Invalid_Argument;
 547         goto Fail;
 548       }
 549
 550       c = cff->charset.sids[glyph_index];
 551
 552       if ( cid )
 553         *cid = c;
 554     }
 555
 556   Fail:
 557     return error;
 558   }
 559
 560
 561   FT_DEFINE_SERVICE_CIDREC(cff_service_cid_info,
 562     (FT_CID_GetRegistryOrderingSupplementFunc)cff_get_ros,
 563     (FT_CID_GetIsInternallyCIDKeyedFunc)      cff_get_is_cid,
 564     (FT_CID_GetCIDFromGlyphIndexFunc)         cff_get_cid_from_glyph_index
 565   )
 566
 567
 568   /*************************************************************************/
 569   /*************************************************************************/
 570   /*************************************************************************/
 571   /****                                                                 ****/
 572   /****                                                                 ****/
 573   /****                D R I V E R  I N T E R F A C E                   ****/
 574   /****                                                                 ****/
 575   /****                                                                 ****/
 576   /*************************************************************************/
 577   /*************************************************************************/
 578   /*************************************************************************/
 579 #ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
 580   FT_DEFINE_SERVICEDESCREC6(cff_services,
 581     FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF,
 582     FT_SERVICE_ID_POSTSCRIPT_INFO,      &CFF_SERVICE_PS_INFO_GET,
 583     FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &CFF_SERVICE_PS_NAME_GET,
 584     FT_SERVICE_ID_GLYPH_DICT,           &CFF_SERVICE_GLYPH_DICT_GET,
 585     FT_SERVICE_ID_TT_CMAP,              &CFF_SERVICE_GET_CMAP_INFO_GET,
 586     FT_SERVICE_ID_CID,                  &CFF_SERVICE_CID_INFO_GET
 587   )
 588 #else
 589   FT_DEFINE_SERVICEDESCREC5(cff_services,
 590     FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CFF,
 591     FT_SERVICE_ID_POSTSCRIPT_INFO,      &CFF_SERVICE_PS_INFO_GET,
 592     FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &CFF_SERVICE_PS_NAME_GET,
 593     FT_SERVICE_ID_TT_CMAP,              &CFF_SERVICE_GET_CMAP_INFO_GET,
 594     FT_SERVICE_ID_CID,                  &CFF_SERVICE_CID_INFO_GET
 595   )
 596 #endif
 597
 598   FT_CALLBACK_DEF( FT_Module_Interface )
 599   cff_get_interface( FT_Module    driver,       /* CFF_Driver */
 600                      const char*  module_interface )
 601   {
 602     FT_Library           library;
 603     FT_Module            sfnt;
 604     FT_Module_Interface  result;
 605
 606
 607     /* CFF_SERVICES_GET derefers `library' in PIC mode */
 608 #ifdef FT_CONFIG_OPTION_PIC
 609     if ( !driver )
 610       return NULL;
 611     library = driver->library;
 612     if ( !library )
 613       return NULL;
 614 #endif
 615
 616     result = ft_service_list_lookup( CFF_SERVICES_GET, module_interface );
 617     if ( result != NULL )
 618       return result;
 619
 620     /* `driver' is not yet evaluated in non-PIC mode */
 621 #ifndef FT_CONFIG_OPTION_PIC
 622     if ( !driver )
 623       return NULL;
 624     library = driver->library;
 625     if ( !library )
 626       return NULL;
 627 #endif
 628
 629     /* we pass our request to the `sfnt' module */
 630     sfnt = FT_Get_Module( library, "sfnt" );
 631
 632     return sfnt ? sfnt->clazz->get_interface( sfnt, module_interface ) : 0;
 633   }
 634
 635
 636   /* The FT_DriverInterface structure is defined in ftdriver.h. */
 637
 638 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
 639 #define CFF_SIZE_SELECT cff_size_select
 640 #else
 641 #define CFF_SIZE_SELECT 0
 642 #endif
 643
 644   FT_DEFINE_DRIVER( cff_driver_class,
 645
 646       FT_MODULE_FONT_DRIVER       |
 647       FT_MODULE_DRIVER_SCALABLE   |
 648       FT_MODULE_DRIVER_HAS_HINTER,
 649
 650       sizeof ( CFF_DriverRec ),
 651       "cff",
 652       0x10000L,
 653       0x20000L,
 654
 655       0,   /* module-specific interface */
 656
 657       cff_driver_init,
 658       cff_driver_done,
 659       cff_get_interface,
 660
 661     /* now the specific driver fields */
 662     sizeof ( TT_FaceRec ),
 663     sizeof ( CFF_SizeRec ),
 664     sizeof ( CFF_GlyphSlotRec ),
 665
 666     cff_face_init,
 667     cff_face_done,
 668     cff_size_init,
 669     cff_size_done,
 670     cff_slot_init,
 671     cff_slot_done,
 672
 673     ft_stub_set_char_sizes,  /* FT_CONFIG_OPTION_OLD_INTERNALS */
 674     ft_stub_set_pixel_sizes, /* FT_CONFIG_OPTION_OLD_INTERNALS */
 675
 676     cff_glyph_load,
 677
 678     cff_get_kerning,
 679     0,                       /* FT_Face_AttachFunc */
 680     cff_get_advances,
 681
 682     cff_size_request,
 683
 684     CFF_SIZE_SELECT
 685   )
 686
 687
 688 /* END */