diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /fonts/utilities/ps2mf |
Initial commit
Diffstat (limited to 'fonts/utilities/ps2mf')
30 files changed, 14490 insertions, 0 deletions
diff --git a/fonts/utilities/ps2mf/AFMparse.c b/fonts/utilities/ps2mf/AFMparse.c new file mode 100644 index 0000000000..649a72a1cb --- /dev/null +++ b/fonts/utilities/ps2mf/AFMparse.c @@ -0,0 +1,552 @@ +/* AFM_parse.c */ + +#include <stdio.h> +#ifndef AIX +#include <stdlib.h> +# endif +#include <string.h> +#include "defines.h" +#include "myopen.h" +#include "mymalloc.h" +#include "ps2mf.h" +#include "ps2mfutl.h" +#include "AFMparse.h" +#ifdef MSDOS +#include <float.h> +#endif + +#ifdef __STDC__ +int AFM_command (char * s) +#else +int AFM_command (s) +char * s; +#endif +{ + char ** p; + int n; + + for (p = AFM_key_words, n = 0; * p; p ++, n ++) + { + if (strequ (s, * p)) return (n); + } + return (not_an_AFM_keyword); +} + +#ifdef __STDC__ +int find_TeX_num (char * p) +#else +int find_TeX_num (p) +char * p; +#endif +{ + AFM_info_tp * ai; + + for (ai = AFM_chars; ai; ai = ai -> next) + { + if (strequ (p, ai -> AFM_name)) return (ai -> TeX_num); + } + fprintf (stderr, "! No TeX coding found for character %s\n", p); + error ("! Are you sure the configuration file is OK?\n"); +} + +kern_tp * new_kern () +{ + kern_tp * nk; + + nk = (kern_tp *) my_malloc (sizeof (kern_tp)); + nk -> next = NULL; + nk -> succ = NULL; + nk -> delta = 0; + return (nk); +} + +AFM_info_tp * new_char () +{ + AFM_info_tp * ai; + + ai = (AFM_info_tp *) my_malloc (sizeof (AFM_info_tp)); + ai -> AFM_num = -1; + ai -> TeX_num = -1; + ai -> width = -1; + ai -> AFM_name = NULL; + ai -> bbox_llx = -1; + ai -> bbox_lly = -1; + ai -> bbox_urx = -1; + ai -> bbox_ury = -1; + ai -> ligs = NULL; + ai -> kerns = NULL; + ai -> pccs = NULL; + ai -> next = AFM_chars; + ai -> in_MF_file = FALSE; + AFM_chars = ai; + return (ai); +} + +lig_tp * new_lig () +{ + lig_tp * nl; + + nl = (lig_tp *) my_malloc (sizeof (lig_tp)); + nl -> next = NULL; + nl -> succ = NULL; + nl -> sub = NULL; + return (nl); +} + +void process_char () +{ + AFM_info_tp * ai; + configuration_info_tp * ci; + lig_tp * nl, * cilig; + + ai = new_char (); + ai -> AFM_num = param_num (); + expect (";"); + expect ("WX"); + ai -> width = transform (param_num (), 0); + expect (";"); + expect ("N"); + ai -> AFM_name = param_new_string (); + expect (";"); + expect ("B"); + ai -> bbox_llx = param_num (); + ai -> bbox_lly = param_num (); + ai -> bbox_urx = param_num (); + ai -> bbox_ury = param_num (); + ai -> bbox_llx = transform (ai -> bbox_llx, ai -> bbox_lly); + ai -> bbox_urx = transform (ai -> bbox_urx, ai -> bbox_ury); + if (ai -> bbox_lly > 0) ai -> bbox_lly = 0; + if (ai -> bbox_ury < 0) ai -> bbox_ury = 0; + if (strequ (ai -> AFM_name, "space")) font_space = ai -> width; + if (strequ (ai -> AFM_name, "M")) font_quad = ai -> width; + if (strequ (ai -> AFM_name, "x") && ! x_height_is_defined) + { + x_height = ai -> bbox_ury; + } + expect (";"); + while (* param == 'L') + { + expect ("L"); + nl = new_lig (); + nl -> succ = param_new_string (); + nl -> sub = param_new_string (); + nl -> next = ai -> ligs; + ai -> ligs = nl; + expect (";"); + } + for (ci = TeX_configuration; ci; ci = ci -> next) + { + if (strequ (ai -> AFM_name, ci -> AFM_name)) + { + for (cilig = ci -> ligs; cilig; cilig = cilig -> next) + { + nl = new_lig (); + nl -> succ = cilig -> succ; + nl -> sub = cilig -> sub; + nl -> next = ai -> ligs; + ai -> ligs = nl; + } + } + } +} + +void process_kern () +{ + AFM_info_tp * ai; + char * p; + kern_tp * nk; + + p = param_string (); + if (strequ (p, "space")) return; + ai = find_AFM_info_for (p); + if (ai == NULL) error ("! kern char not found"); + if (ai -> AFM_num < '0' || ai -> AFM_num > '9') + { + nk = new_kern (); + nk -> succ = param_new_string (); + if (strequ (nk -> succ, "space")) return; + nk -> delta = transform (param_num (), 0); + nk -> next = ai -> kerns; + ai -> kerns = nk; + } +} + +pcc_tp * new_pcc () +{ + pcc_tp * np; + + np = (pcc_tp *) my_malloc (sizeof (pcc_tp)); + np -> next = NULL; + np -> part_name = NULL; + np -> x_offset = 0; + np -> y_offset = 0; + return (np); +} + +void process_composite_char () +{ + AFM_info_tp * ai; + char * p; + pcc_tp * np; + int n; + pcc_tp * npp = NULL; + + p = param_string (); + ai = find_AFM_info_for (p); + if (ai == NULL) error ("! composite character name not found"); + n = param_num (); + expect (";"); + while (n --) + { + expect ("PCC"); /* see afm2tfm.c: handleconstruct*/ + np = new_pcc (); + np -> part_name = param_new_string (); + if (find_AFM_info_for (np -> part_name) == NULL) return; + np -> x_offset = param_num (); + np -> y_offset = param_num (); + np -> x_offset = transform (np -> x_offset, np -> y_offset); + if (npp) npp -> next = np; + else ai -> pccs = np; + npp = np; + expect (";"); + } +} + +#ifdef __STDC__ +void append_liginfo (lig_tp * ail, lig_tp * cil) +# else +void append_liginfo (ail, cil) +lig_tp * ail, * cil; +# endif +{ + lig_tp * dummy_cil; + + if (ail == NULL) + { + ail = cil; + return; + } + if (cil == NULL) return; + dummy_cil = cil; + while (dummy_cil -> next != NULL) dummy_cil = dummy_cil -> next; + dummy_cil -> next = ail; + ail = cil; +} + +void assign_chars () +{ + char ** p; + int i; + bool stop; + AFM_info_tp * ai; + configuration_info_tp * ci; + int nextfree; + + for (ai = AFM_chars; ai; ai = ai -> next) + { + stop = FALSE; ci = TeX_configuration; + while (! stop && ci) + { + if (strequ (ai -> AFM_name, ci -> AFM_name)) + { + ai -> TeX_num = ci -> TeX_num; + append_liginfo (ai -> ligs, ci -> ligs); + stop = TRUE; + } + ci = ci -> next; + } + } +} + +void delete_TeX_configuration () +{ + configuration_info_tp * ci; + + while (TeX_configuration) + { + ci = TeX_configuration -> next; + free (TeX_configuration); + TeX_configuration = ci; + } +} + +void parse_AFM () +{ + strcpy (font_name, "Unknown"); + italic_angle = 0.0; + fixed_pitch = FALSE; + x_height = 400; + font_space = 250; + font_quad = 800; + x_height_is_defined = FALSE; + + + while (get_line (afm_file)) + { + switch (AFM_command (param_string ())) + { + case FontName: + { + strcpy (font_name, param_string ()); + } + break; + case EncodingScheme: + { + /*strcpy (coding_scheme, param_string ());*/ + } + break; + case ItalicAngle: + { + italic_angle = param_float (); + } + break; + case IsFixedPitch: + { + if (* param == 't' || * param == 'T') + { + fixed_pitch = TRUE; + } + else fixed_pitch = FALSE; + } + break; + case XHeight: + { + x_height = param_num (); + x_height_is_defined = TRUE; + } + break; + case C: + { + process_char (); + } + break; + case KPX: + { + process_kern (); + } + break; + case CC: + { + process_composite_char (); + } + break; + default: + break; + } + } + assign_chars (); + delete_TeX_configuration (); +} + +#ifdef __STDC__ +int config_command (char * s) +#else +int config_command (s) +char * s; +#endif +{ + char ** p; + int n; + + for (p = config_key_words, n = 0; * p; p ++, n ++) + { + if (strequ (s, * p)) return (n); + } + return (not_a_config_keyword); +} + +configuration_info_tp * new_conf_info () +{ + configuration_info_tp * nsl; + + nsl = (configuration_info_tp *) + my_malloc (sizeof (configuration_info_tp)); + nsl -> TeX_num = 0; + nsl -> AFM_name = NULL; + nsl -> ligs = NULL; + nsl -> next = TeX_configuration; + TeX_configuration = nsl; + return (nsl); +} + +#ifdef __STDC__ +void process_configuration (int base) +# else +void process_configuration (base) +int base; +# endif +{ + configuration_info_tp * ci; + lig_tp * nl; + + ci = new_conf_info (); + if (base == 8) ci -> TeX_num = param_oct (); + else if (base == 10) ci -> TeX_num = param_num (); + else if (base == 16) ci -> TeX_num = param_hex (); + expect (";"); + expect ("N"); + ci -> AFM_name = param_new_string (); + expect (";"); + while (* param == 'L') + { + expect ("L"); + nl = new_lig (); + nl -> succ = param_new_string (); + nl -> sub = param_new_string (); + nl -> next = ci -> ligs; + ci -> ligs = nl; + expect (";"); + } +} + +ignore_info_tp * new_ignore_info () +{ + ignore_info_tp * nii; + + nii = (ignore_info_tp *) + my_malloc (sizeof (ignore_info_tp)); + nii -> AFM_name = NULL; + nii -> next = ignore_list; + ignore_list = nii; + return (nii); +} + +void process_ignore () +{ + ignore_info_tp * ii; + + ii = new_ignore_info (); + ii -> AFM_name = param_new_string (); + expect (";"); +} + +void process_encoding () +{ + strcpy (coding_scheme, param_string ()); + while (* param != ';') + { + strcat (coding_scheme, " "); + strcat (coding_scheme, param_string ()); + } + expect (";"); +} + +void parse_config () +{ + strcpy (coding_scheme, "Unspecified"); + while (get_line (conf_file)) + { + switch (config_command (param_string ())) + { + case config_C: + case config_D: + { + process_configuration (10); + } + break; + case config_H: + { + process_configuration (16); + } + break; + case config_O: + { + process_configuration (8); + } + break; + case config_I: + { + process_ignore (); + } + break; + case config_Encoding: + { + process_encoding (); + } + break; + default: + break; + } + } +} + +#ifdef __STDC__ +void process_ligatures (AFM_info_tp * ai) +# else +void process_ligatures (ai) +AFM_info_tp * ai; +# endif +{ + AFM_info_tp * ai2, * ai3; + + while (ai -> ligs != NULL) + { + if (! has_ligs [ai -> TeX_num]) + { + ai2 = find_AFM_info_for (ai -> ligs -> succ); + ai3 = find_AFM_info_for (ai -> ligs -> sub); + if (ai2 -> in_MF_file && ai3 -> in_MF_file) + { + if (first_ligtable_entry) + fprintf (mf_file, "\nligtable %d", + ai -> TeX_num); + fprintf (mf_file, "%s%d=:%d", + first_ligtable_entry ? ":\n" : ",\n", + ai2 -> TeX_num, ai3 -> TeX_num); + has_ligs [ai -> TeX_num] = TRUE; + first_ligtable_entry = FALSE; + } + } + ai -> ligs = ai -> ligs -> next; + } +} + +#ifdef __STDC__ +void process_kerns (AFM_info_tp * ai) +# else +void process_kerns (ai) +AFM_info_tp * ai; +# endif +{ + AFM_info_tp * ai2; + + while (ai -> kerns != NULL) + { + if (! has_ligs [ai -> TeX_num]) + { + ai2 = find_AFM_info_for (ai -> kerns -> succ); + if (ai2 -> in_MF_file) + { + if (first_ligtable_entry) + fprintf (mf_file, "\nligtable %d", + ai -> TeX_num); + fprintf (mf_file, "%s%d kern %dFX#", + first_ligtable_entry ? ":\n" : ",\n", + ai2 -> TeX_num, ai -> kerns -> delta); + first_ligtable_entry = FALSE; + } + } + ai -> kerns = ai -> kerns -> next; + } +} + +void process_ligatures_and_kerns () +{ + AFM_info_tp * ai, * ai2, * ai3; + int i; + + fprintf (stderr, "Generating a ligaturetable\n"); + for (ai = AFM_chars; ai; ai = ai -> next) + { + for (i = 0; i < 255; i ++) has_ligs [i] = FALSE; + first_ligtable_entry = TRUE; + if (ai -> in_MF_file && (ai -> ligs != NULL + || ai -> kerns != NULL)) + { + if (ai -> ligs != NULL) process_ligatures (ai); + if (ai -> kerns != NULL) process_kerns (ai); + if (! first_ligtable_entry) fprintf (mf_file, ";\n"); + } + } +} + diff --git a/fonts/utilities/ps2mf/AFMparse.h b/fonts/utilities/ps2mf/AFMparse.h new file mode 100644 index 0000000000..39a490493c --- /dev/null +++ b/fonts/utilities/ps2mf/AFMparse.h @@ -0,0 +1,67 @@ +/* AFM_parse.h */ + +char * AFM_key_words [] = +{ + "FontName", + "ItalicAngle", + "IsFixedPitch", + "XHeight", + "C", + "KPX", + "CC", + "EncodingScheme", + NULL +}; + +#define FontName (0) +#define ItalicAngle (1) +#define IsFixedPitch (2) +#define XHeight (3) +#define C (4) +#define KPX (5) +#define CC (6) +#define EncodingScheme (7) +#define not_an_AFM_keyword (-1) + +char * config_key_words [] = +{ + "C", + "D", + "H", + "O", + "I", + "Encoding", + NULL +}; + +#define config_C (0) +#define config_D (1) +#define config_H (2) +#define config_O (3) +#define config_I (4) +#define config_Encoding (5) +#define not_a_config_keyword (-1) + +bool has_ligs [255], first_ligtable_entry; + +int AFM_command __P((char * s)); +void append_liginfo __P((lig_tp * ail, lig_tp * cil)); +void assign_chars __P((void)); +int config_command __P((char * s)); +void delete_TeX_configuration __P((void)); +AFM_info_tp * new_char __P((void)); +ignore_info_tp * new_ignore_info __P((void)); +kern_tp * new_kern __P((void)); +lig_tp * new_lig __P((void)); +pcc_tp * new_pcc __P((void)); +configuration_info_tp * new_conf_info __P((void)); +void parse_AFM __P((void)); +void parse_config __P((void)); +void process_char __P((void)); +void process_composite_char __P((void)); +void process_configuration __P((int base)); +void process_ignore __P((void)); +void process_kern __P((void)); +void process_kerns __P((AFM_info_tp * ai)); +void process_ligatures __P((AFM_info_tp * ai)); +char * name_from_AFM_num __P((int afm_num)); /* ILH */ diff --git a/fonts/utilities/ps2mf/Makefile b/fonts/utilities/ps2mf/Makefile new file mode 100644 index 0000000000..aabcb8a24a --- /dev/null +++ b/fonts/utilities/ps2mf/Makefile @@ -0,0 +1,29 @@ +default: all + +CC = gcc +CFLAGS = -g -DUSG -DDEBUG + +MYOBJS = myopen.o myerror.o mymalloc.o +EXTRAOBJS = getopt.o +PSTOMFOBJS = ps2mf.o PSparse.o AFMparse.o ps2mfutl.o +PROGS = ps2mf pfb2pfa pfa2chr chr2ps + +all: ${PROGS} + +ps2mf: ${EXTRAOBJS} ${PSTOMFOBJS} myopen.o mymalloc.o + ${CC} ${CFLAGS} -o ps2mf ${PSTOMFOBJS} myopen.o mymalloc.o ${EXTRAOBJS} -lm + +pfb2pfa: ${MYOBJS} ${EXTRAOBJS} pfb2pfa.o + ${CC} ${CFLAGS} -o pfb2pfa pfb2pfa.o ${MYOBJS} ${EXTRAOBJS} + +pfa2chr: ${MYOBJS} ${EXTRAOBJS} pfa2chr.o + ${CC} ${CFLAGS} -o pfa2chr pfa2chr.o ${MYOBJS} ${EXTRAOBJS} + +chr2ps: ${MYOBJS} ${EXTRAOBJS} chr2ps.o + ${CC} ${CFLAGS} -o chr2ps chr2ps.o ${MYOBJS} ${EXTRAOBJS} + +.c.o: $< + ${CC} ${CFLAGS} -c $< + +clean: + rm -f ${MYOBJS} ${EXTRAOBJS} ${PSTOMFOBJS} %* ${PROGS} diff --git a/fonts/utilities/ps2mf/PSparse.c b/fonts/utilities/ps2mf/PSparse.c new file mode 100644 index 0000000000..f58e4221a4 --- /dev/null +++ b/fonts/utilities/ps2mf/PSparse.c @@ -0,0 +1,1498 @@ +/* PSparse.c */ + +#include <stdio.h> +#ifndef AIX +#include <stdlib.h> +#endif +#include <string.h> +#include <math.h> +#include <ctype.h> +#include "defines.h" +#include "myopen.h" +#include "mymalloc.h" +#include "ps2mf.h" +#include "ps2mfutl.h" +#include "PSparse.h" +#ifdef MSDOS +#include <float.h> +#endif + +float x_scale, y_scale; + +void write_MF_header () +{ + int i; + + fprintf (mf_file, "%% %s\n", font_name); + fprintf (mf_file, "mode_setup;\n"); + fprintf (mf_file, "if unknown FontSize: FontSize := 10pt#; fi\n"); + fprintf (mf_file, "FX# := FontSize * %.4f;\n", x_scale); + fprintf (mf_file, "FY# := FontSize * %.4f;\n", y_scale); + fprintf (mf_file, "bot_blues.n := %d;\n", num_of_other_blues + 1); + fprintf (mf_file, "bot_blues1o := %d;\n", blue_values [0] . overshoot); + fprintf (mf_file, "bot_blues1p := %d;\n", blue_values [0] . position); + for (i = 0; i < num_of_other_blues; i ++) + { + fprintf (mf_file, "bot_blues%do := %d;\n", i + 2, + other_blues [i] . overshoot); + fprintf (mf_file, "bot_blues%dp := %d;\n", i + 2, + other_blues [i] . position); + } + fprintf (mf_file, "top_blues.n := %d;\n", num_of_blue_values - 1); + for (i = 1; i < num_of_blue_values; i ++) + { + fprintf (mf_file, "top_blues%do := %d;\n", i, + blue_values [i] . overshoot); + fprintf (mf_file, "top_blues%dp := %d;\n", i, + blue_values [i] . position); + } + fprintf (mf_file, "blue_scale := %g;\n", blue_scale); + fprintf (mf_file, "blue_shift := %d;\n", blue_shift); + fprintf (mf_file, "blue_fuzz := %d;\n", blue_fuzz); + fprintf (mf_file, "\ninput hints;\n"); +} + +void write_MF_trailer () +{ + fprintf (mf_file, "\nfont_slant := %.4f;\n", 1 - cos (italic_angle)); + fprintf (mf_file, "font_normal_space := %d * FX#;\n", font_space); + fprintf (mf_file, "font_normal_stretch := %d * FX#;\n", + (int) (font_space / 2.0)); + fprintf (mf_file, "font_normal_shrink := %d * FX#;\n", + (int) (font_space / 3.0)); + fprintf (mf_file, "font_x_height := %d * FY#;\n", (int) x_height); + if (font_quad > 0) + { + fprintf (mf_file, "font_quad := %d * FX#;\n", font_quad); + } + else + { + fprintf (mf_file, "font_quad := %d * FX#;\n", (font_space * 3)); + } + fprintf (mf_file, "designsize := FontSize;\n"); + fprintf (mf_file, "font_coding_scheme := \"%s\";\n", coding_scheme); + fprintf (mf_file, "font_identifier := \"%s\";\n", font_name); + fprintf (mf_file, "end.\n"); + fprintf (mf_file, "%% That's all, Folks!\n"); +} + +#ifdef __STDC__ +void push (float fl) +#else +void push (fl) +float fl; +#endif +{ + if (top_of_stack >= MAX_stack) error ("! stack overflow"); + stack [top_of_stack] = fl; + top_of_stack ++; +} + +float pop () +{ + top_of_stack --; + if (top_of_stack < 0) error ("! stack underflow"); + return (stack [top_of_stack]); +} + +#ifdef __STDC__ +void eat_this_character (char * s) +#else +void eat_this_character (s) +char * s; +#endif +{ + char * this_param_string; + + do + { + get_token (ps_file); + this_param_string = param_string (); + } + while (! (strequ (this_param_string, "ND") + || strequ (this_param_string, "|-"))); +} + +#ifdef __STDC__ +bool ignore_this_character (char * s) +# else +bool ignore_this_character (s) +char * s; +# endif +{ + ignore_info_tp * ii; + + for (ii = ignore_list; ii; ii = ii -> next) + { + if (strequ (ii -> AFM_name, s)) return (TRUE); + } + return (FALSE); +} + +#ifdef __STDC__ +int charstring_command (char * s) +#else +int charstring_command (s) +char * s; +#endif +{ + char ** p; + int n; + + if (s [0] == '/') + { + s ++; + if (ignore_this_character (s) + || ((strstr (obuffer, "seac") != NULL) + && ! processing_seacs) + || ((strstr (obuffer, "seac") == NULL) + && processing_seacs)) + { + if (! have_found_seacs) have_found_seacs = TRUE; + eat_this_character (s); + return (not_a_charstring_command); + } + strcpy (current_char, s); + return (charstring_command_char); + } + for (p = charstring_commands, n = 0; * p; p ++, n ++) + if (strequ (s, * p)) return (n); + if (sscanf (s, "%f", & numeric_val) == 1) + return (charstring_command_numeric); + if (strequ (s, "end")) return (charstring_commands_end); + return (not_a_charstring_command); +} + +#ifdef __STDC__ +int PS_header_command () +#else +int PS_header_command () +#endif +{ + char ** p; + int n; + + for (p = PS_header_commands, n = 0; * p; p ++, n ++) + if (strstr (obuffer, * p) != NULL) return (n); + return (not_a_PS_header_command); +} + +/* Charstring Command Handling */ + +/* Commands for Starting and Finishing */ + +bool candidate_for_seac () +{ + char ** p; + + for (p = seac_candidates; * p; p ++) + if (strequ (current_char, * p)) + return (TRUE); + return (FALSE); +} + +void do_endchar () +{ + /* + finishes a charstring outline definition and must be the last command + in a character's outline (except for accented character defined using + *seac*). When *endchar* is executed, Type 1 BuildChar performs several + tasks. It executes a *setcachedevice* operation, using a bounding box + it computes directly from the character outline and using the width + information acquired from a previous *hsbw* or *sbw* operation. (Note + that this is not the same order of events as in Type 3 Fonts.) + BuildChar then calls a special version of *fill* or *stroke* depending + on the value of *PaintType* in the font dictionary. The Type 1 font + format supports only *PaintType* 0 (fill) and 2 (outline). Note that + this single *fill* or *stroke* implies that there can be only one path + (possibly containing several subpaths) that can be created to be + filled or stroked by the *endchar* command. + */ + + if (active_path) do_closepath (); + if (candidate_for_seac ()) + { + fprintf (mf_file, "chp[%d]:=currentpicture;\n", + current_AFM_num); + } + fprintf (mf_file, "endchar;\n"); +} + +#ifdef __STDC__ +void do_hsbw (float sbx, float wx) +#else +void do_hsbw (sbx, wx) +float sbx, wx; +#endif +{ + /* + sets the left sidebearing point at (sbx, 0) and sets the character + width vector to (wx, 0) in character space. This command also sets the + currentpoint to (sbx, 0), but does not place the point in the + character path. Use *rmoveto* for the first point in the path. The + name *hsbw* stands for horizontal sidebearing and width; horizontal + indicates that the y component of both the sidebearing and width is 0. + Either *sbw* or *hsbw* must be used once as the first command in a + character outline definition. It must be used only once. In + non-marking characters, such as the space character, the left + sidebearing point should be (0, 0). + */ + + do_sbw (sbx, 0.0, wx, 0.0); +} + +#ifdef __STDC__ +void do_seac (float asb, float adx, float ady, int bchar, int achar) +#else +void do_seac (asb, adx, ady, bchar, achar) +float asb, adx, ady; +int bchar, achar; +#endif +{ + /* + for standard encoding accented character, makes an accented character + from two other characters in its font program. The asb argument is the + x component of the left sidebearing of the accent; this value must be + the same as the sidebearing value given in the *hsbw* or *sbw* command + in the accent's own charstring. The origin of the accent is placed at + (adx, ady) relative to the origin of the base character. The bchar + argument is the character code of the base character, and the achar + argument is the the character code of the accent character. Both bchar + and achar are codes that these characters are assigned in the Adobe + StandardEncoding vector, given in an Appendix in the PostScript + Language Reference Manual. Furthermore, the characters represented by + achar and bchar must be in the same position in the font's encoding + vector as the positions they occupy in the Adobe StandardEncoding + vector. If the name of both components of an accented character do not + appear in the Adobe StandardEncoding vector, the accented character + cannot be build using the *seac* command. + + The *FontBBox* entry in the font dictionary must be large enough to + accommodate both parts of the accented character. The *sbw* or *hsbw* + command that begins the accented character must be the same as the + corresponding command in the base character. Finally, *seac* is the + last command in the charstring for the accented character because the + accent and base characters' charstrings each already end with their + own *endchar* commands. + + The use of this command saves space in a Type 1 font program, but its + use is restricted to those characters whose parts are defined in the + Adobe StandardEncoding vector. In situations where use of the *seac* + command is not possible, use of *Subrs* subroutines is a more general + means for creating accented characters. + */ + fprintf (mf_file, "seac(%d,%d,%g,%g)\n", achar, bchar, + adx + current_point . x - asb, ady); + fprintf (mf_file, "endchar;\n"); +} + +#ifdef __STDC__ +void do_sbw (float sbx, float sby, float wx, float wy) +#else +void do_sbw (sbx, sby, wx, wy) +float sbx, sby, wx, wy; +#endif +{ + /* + sets the left sidebearing point to (sbx, sby) and sets the character + width vector to (wx, wy) in character space. This command also sets + the current point to (sbx, sby), but does not place the point in the + character path. Use *rmoveto* for the first point in the path. The + name *sbw* stands for sidebearing and width; the x and y components of + both the left sidebearing and width must be specified. If the y + components of both the left sidebearing and the width are 0, then the + *hsbw* command should be used. Either *sbw* or *hsbw* must be used + once as the first command in a character outline definition. It must + be used only once. + */ + + current_point . x = sbx; + current_point . y = sby; + the_sbx = sbx; +} + +/* Path Construction Commands */ + +void do_closepath () +{ + /* + *closepath* closes a subpath. Adobe strongly recommends that all + character subpaths end with a *closepath* command, otherwise when an + outline is stroked (by setting *PaintType* equal to 2) you may get + unexpected behaviour where lines join. Note that, unlike the + *closepath* command in the PostScript language, this command does not + reposition the current point. Any subsequent *rmoveto* must be + relative to the current point in force before the Type 1 format + *closepath* command was given. + + Make sure that any subpath section formed by the *closepath* command + intended to be zero length, is zero length. If not, the *closepath* + command may cause a "spike" or "hangnail" (if the subpath doubles back + onto itself) with unexpected results. + */ + + fprintf (mf_file, " )cp\n"); + active_path = FALSE; + after_hint = FALSE; +} + +#ifdef __STDC__ +void do_hlineto (float dx) +#else +void do_hlineto (dx) +float dx; +#endif +{ + /* + for horizontal lineto. Equivalent to dx 0 *rlineto*. + */ + + do_rlineto (dx, 0.0); +} + +#ifdef __STDC__ +void do_hmoveto (float dx) +#else +void do_hmoveto (dx) +float dx; +#endif +{ + /* + for horizontal lineto. Equivalent to dx 0 *rmoveto*. + */ + + do_rmoveto (dx, 0.0); +} + +#ifdef __STDC__ +void do_hvcurveto (float dx1, float dx2, float dy2, float dy3) +#else +void do_hvcurveto (dx1, dx2, dy2, dy3) +float dx1, dx2, dy2, dy3; +#endif +{ + /* + for horizontal-vertical curveto. Equivalent to dx1 0 dx2 dy2 0 dy3 + *rrcurveto*. This command eliminates two arguments from an *rrcurveto* + call when the first B'ezier tangent is horizontal and the second + B'ezier tangent is vertical. + */ + + do_rrcurveto (dx1, 0.0, dx2, dy2, 0.0, dy3); +} + +#ifdef __STDC__ +void do_rlineto (float dx, float dy) +#else +void do_rlineto (dx, dy) +float dx, dy; +#endif +{ + /* + (relative *lineto*) appends a straight line segment to the current + path in the same manner as *lineto*. However, the number pair is + interpreted as a displacement relative to the current point (x, y) + rather than as an absolute coordinate. That is, *rlineto* constructs a + line from (x, y) to (x + dx, y + dy) and makes (x + dx, y + dy) the + new current point. If the current point is undefined because the + current path is empty, *rlineto* executes the error *nocurrentpoint*. + */ + + current_point . x += dx; + current_point . y += dy; + fprintf (mf_file, "lt%s(%g,%g)\n", + after_hint ? "h" : "", + current_point . x, + current_point . y); + after_hint = FALSE; +} + +#ifdef __STDC__ +void do_rmoveto (float dx, float dy) +#else +void do_rmoveto (dx, dy) +float dx, dy; +#endif +{ + /* + (relative *moveto*) starts a new subpath of the current path in the + same manner as *moveto*. However, the number pair is interpreted as a + displacement relative to the current point (x, y) rather than as an + absolute coordinate. That is, *rmoveto* makes (x + dx, y + dy) the new + currentpoint, without connecting it to the previous point. If the + current point is undefined because the current path is empty, *moveto* + executes the error *nocurrentpoint*. + */ + + current_point . x += dx; + current_point . y += dy; + if (active_path) do_closepath (); + path_number ++; active_path = TRUE; + if (after_hint) fprintf (mf_file, "ih\n"); + fprintf (mf_file, "dr\n"); + fprintf (mf_file, "ah((%g,%g)\n", current_point . x, + current_point . y); + after_hint = FALSE; +} + +#ifdef __STDC__ +void do_rrcurveto (float dx1, float dy1, float dx2, float dy2, float dx3, + float dy3) +#else +void do_rrcurveto (dx1, dy1, dx2, dy2, dx3, dy3) +float dx1, dy1, dx2, dy2, dx3, dy3; +#endif +{ + /* + for relative *rcurveto*. Whereas the arguments to the *rcurveto* + operator in the PostScript language are all relative to the current + point, the arguments to *rrcurveto* are relative to each other. + Equivalent to dx1 dy1 (dx1 + dx2) (dy1 + dy2) (dx1 + dx2 + dx3, dy1 + + dy2 + dy3) *rcurveto*. + */ + + do_rcurveto (dx1, dy1, dx1 + dx2, dy1 + dy2, dx1 + dx2 + dx3, + dy1 + dy2 + dy3); +} + +#ifdef __STDC__ +void do_vhcurveto (float dy1, float dx2, float dy2, float dx3) +#else +void do_vhcurveto (dy1, dx2, dy2, dx3) +float dy1, dx2, dy2, dx3; +#endif +{ + /* + for vertical-horizontal curveto. Equivalent to 0 dy1 dx2 dy2 dx3 0 + *rrcurveto*. This command eliminates two arguments from an *rrcurveto* + call when the first B'ezier tangent is vertical and the second B'ezier + tangent is horizontal. + */ + + do_rrcurveto (0.0, dy1, dx2, dy2, dx3, 0.0); +} + +#ifdef __STDC__ +void do_vlineto (float dy) +#else +void do_vlineto (dy) +float dy; +#endif +{ + /* + for vertical lineto. This is equivalent to 0 dy *rlineto*. + */ + + do_rlineto (0.0, dy); +} + +#ifdef __STDC__ +void do_vmoveto (float dy) +#else +void do_vmoveto (dy) +float dy; +#endif +{ + /* + for vertical moveto. This is equivalent to 0 dy *rmoveto*. + */ + + do_rmoveto (0.0, dy); +} + +void do_dotsection () +{ + /* + brackets an outline section for the dots in letters such as "i", "j" + and "!". This is a hint command that indicates that a section of a + charstring should be understood as describing such a feature, rather + than as port of the main outline. + */ + +} + +#ifdef __STDC__ +void do_hstem (float y, float dy) +#else +void do_hstem (y, dy) +float y, dy; +#endif +{ + /* + declares the vertical range of a horizontal stem zone between the y + coordinates y and y + dy, where y is relative to the y coordinate of + the left sidebearing point. Horizontal stem zones within a set of stem + hints for a single character may not overlap other horizontal stem + zones. Use hint replacement to avoid stem hint overlaps. + */ + + if (dy >= 0) fprintf (mf_file, "dh(\"hs(%g,%g)\")\n", y, y + dy); + else fprintf (mf_file, "dh(\"hs(%g,%g)\")\n", y + dy, y); + after_hint = TRUE; +} + +#ifdef __STDC__ +void do_hstem3 (float y0, float dy0, float y1, float dy1, float y2, float dy2) +#else +void do_hstem3 (y0, dy0, y1, dy1, y2, dy2) +float y0, dy0, y1, dy1, y2, dy2; +#endif +{ + /* + declares the vertical ranges of three horizontal stem zones between + the y coordinates y0 and y0 + dy0, y1 and y1 + dy2, and between y2 and + y2 + dy2, where y0, y1 and y2 are all relative to the y coordinate of + the left sidebearing point. The *hstem3* command sorts these zones by + the y values to obtain the lowest, middle and highest zones, called + ymin, ymid and ymax respectively. The corresponding dy values are + called dymin, dymid and dymax. These stems and the counters between + them will all be controled. These coordinates must obey certain + restrictions: + + . dymin = dymax + + . The distance from ymin + dymin/2 to ymid + dymid/2 must equal the + distance from ymid + dymid/2 to ymax + dymax/2. In other words, the + distance from the center of the bottom stem to the center of the + middle stem must be the same as the distance from the center of the + middle stem to the center of the top stem. + + If a charstring uses an *hstem3* command in the hints for a character, + the charstring must not use *hstem* commands and it must use the same + *hstem3* command consistently if hint replacement is performed. + + The *hstem3* command is especially suited for controlling the stems + and counters of symbols with three horizontally oriented features with + equal vertical widths and with equal white space between these + features, such as the mathematical equivalence symbol or the division + symbol. + */ + + do_hstem (y0, dy0); + do_hstem (y1, dy1); + do_hstem (y2, dy2); + fprintf (mf_file, "dh(\"hst\")\n"); +} + +#ifdef __STDC__ +void do_vstem (float x, float dx) +# else +void do_vstem (x, dx) +float x, dx; +# endif +{ + /* + declares the horizontal range of a vertical stem zone between the x + coordinates x and x + dx, where x is relative to the x coordinate of + the left sidebearing point. Vertical stem zones within a set of stem + hints for a single character may not overlap other vertical stem + zones. Use hint replacement to avoid stem hint overlap. + */ + + if (dx >= 0) fprintf (mf_file, "dh(\"vs(%g,%g)\")\n", x + the_sbx, + x + dx + the_sbx); + else fprintf (mf_file, "dh(\"vs(%g,%g)\")\n", x + dx + the_sbx, + x + the_sbx); + after_hint = TRUE; +} + +#ifdef __STDC__ +void do_vstem3 (float x0, float dx0, float x1, float dx1, float x2, float dx2) +#else +void do_vstem3 (x0, dx0, x1, dx1, x2, dx2) +float x0, dx0, x1, dx1, x2, dx2; +#endif +{ + /* + declares the horizontal ranges of three vertical stem zones between + the x coordinates x0 and x0 + dx0, x1 and x1 + dx2, and x2 and x2 + + dx2, where x0, x1 and x2 are all relative to the x coordinate of the + left sidebearing point. The *vstem3* command sorts these zones by the + x values to obtain the leftmost, middle and rightmost zones, called + xmin, xmid and xmax respectively. The corresponding dx values are + called dxmin, dxmid and dxmax. These stems and the counters between + them will all be controled. These coordinates must obey certain + restrictions: + + . dxmin = dxmax + + . The distance from xmin + dxmin/2 to xmid + dxmid/2 must equal the + distance from xmid + dxmid/2 to xmax + dxmax/2. In other words, the + distance from the center of the left stem to the center of the + middle stem must be the same as the distance from the center of the + middle stem to the center of the right stem. + + If a charstring uses an *vstem3* command in the hints for a character, + the charstring must not use *vstem* commands and it must use the same + *vstem3* command consistently if hint replacement is performed. + + The *vstem3* command is especially suited for controlling the stems + and counters of characters such as a lower case "m". + */ + + do_vstem (x0, dx0); + do_vstem (x1, dx1); + do_vstem (x2, dx2); + fprintf (mf_file, "dh(\"vst\")\n"); +} + +#ifdef __STDC__ +void do_rcurveto (float dx1, float dy1, float dx2, float dy2, float dx3, + float dy3) +#else +void do_rcurveto (dx1, dy1, dx2, dy2, dx3, dy3) +float dx1, dy1, dx2, dy2, dx3, dy3; +#endif +{ + /* + (relative *curveto*) adds a B'ezier cubic section to the current path + in the same manner as *curveto*. However, the three number pairs are + interpreted as displacements relative to the current point (x0, y0) + rather than as absolute coordinates. That is, *rcurveto* constructs a + curve from (x0, y0) to (x0 + dx3, y0 + dy3), using (x0 + dx1, y0 + + dy1) and (x0 + dx2, y0 + dy2) as B'ezier control points. + */ + + fprintf (mf_file, "ct%s(%g,%g,%g,%g,%g,%g)\n", + after_hint ? "h" : "", + current_point . x + dx1, + current_point . y + dy1, + current_point . x + dx2, + current_point . y + dy2, + current_point . x + dx3, + current_point . y + dy3); + current_point . x += dx3; + current_point . y += dy3; + after_hint = FALSE; +} + +/* Arithmetic Command */ + +#ifdef __STDC__ +void do_div (float num1, float num2) +#else +void do_div (num1, num2) +float num1, num2; +#endif +{ + /* + divides num1 by num2, producing a result that is always a real even if + both operands are integers + */ + + push (num1 / num2); +} + +/* Subroutine Commands */ + +#ifdef __STDC__ +void do_moveto_for_flex (float dx, float dy) +# else +void do_moveto_for_flex (dx, dy) +float dx, dy; +#endif +{ + current_point . x += dx; + current_point . y += dy; + flex . x [flex . n] = current_point . x; + flex . y [flex . n] = current_point . y; +} + +#ifdef __STDC__ +void do_callothersubr (int othersubr, int n) +#else +void do_callothersubr (othersubr, n) +int othersubr, n; +#endif +{ + /* + is a mechanism used by Type 1 BuildChar to make calls on the + PostScript interpreter. Arguments argn through arg1 are pushed onto + the PostScript interpreter operand stack, and the PostScript language + procedure in the othersubr# position in the *OtherSubrs* array in the + *Private* dictionary (or a built-in function equivalent to this + procedure) is executed. Note that the argument order will be reversed + when pushed onto the PostScript interpreter operand stack. After the + arguments are pushed onto the PostScript interpreter operand stack, + the PostScript interpreter performs a *begin* operation on + *systemdict* followed by a *begin* operation on the font dictionary + prior to executing the *OtherSubrs* entry. When the *OtherSubrs* entry + completes its execution, the PostScript interpreter performs two *end* + operations prior to returning to Type 1 BuildChar charstring + execution. Use *pop* commands to retrieve results from the PostScript + operand stack back to the Type 1 BuildChar operand stack. + */ + + float flex_h; + + switch (othersubr) + { + case 0: + { + (void) pop (); /* end point y */ + (void) pop (); /* end point x */ + flex_h = pop (); /* flex feature height */ + if (! active_flex) + error ("! othersub 1 required before Flex othersub 0\n"); + if (flex . n != 7) + error ("! seven calls to othersub 2 required before Flex othersub 0\n"); + fprintf (mf_file, + " fl%s(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)\n", + after_hint ? "h" : "", + flex . x [0], flex . y [0], + flex . x [1], flex . y [1], + flex . x [2], flex . y [2], + flex . x [3], flex . y [3], + flex . x [4], flex . y[4], + flex . x [5], flex . y [5], + flex . x [6], flex . y [6], + flex_h); + active_flex = after_hint = FALSE; + } + break; + case 1: + { + active_flex = TRUE; + flex . n = 0; + } + break; + case 2: + { + flex . n ++; + } + break; + case 3: + { + if (active_path && ! after_hint) + fprintf (mf_file, " )\n"); + } + break; + } +} + +#ifdef __STDC__ +void do_callsubr (int subr_no) +#else +void do_callsubr (subr_no) +int subr_no; +#endif +{ + /* + calls a charstring subroutine with index subr# form the *Subrs* array + in the *private* dictionary. Each element of the *Subrs* array is a + charstring encoded and encrypted like any other charstring. Arguments + pushed on the Type 1 BuildChar operand stack prior to calling the + subroutine, and results pushed on the stack by the subroutine, act + according to the manner in which the subroutine is coded. These + subroutines are generally used to encode sequences of path commands + that are repeated throughout the font program, for example, serif + outline sequences. Subroutine calls may be nested 10 deep. + */ + + if (Subrs_entries [subr_no] == NULL) + { + error ("! Undefined subroutine called"); + } + processing_Subr = TRUE; + current_Subr ++; + Subrs_stack [current_Subr] = Subrs_entries [subr_no]; +} + +float do_pop () +{ + /* + removes a number from the top of the PostScript interpreter operand + stack and pushes that number onto the Type1 BuildChar operand stack. + This command is used only to retrieve a result from an *OtherSubrs* + procedure. + */ + + return (0.0); +} + +void do_return () +{ + /* + returns from a *Subrs* array charstring subroutine (that had been + called with a *callsubr* command) and continues execution in the + calling charstring. + */ + + current_Subr --; + if (current_Subr < 0) processing_Subr = FALSE; +} + +#ifdef __STDC__ +void do_setcurrentpoint (float x, float y) +#else +void do_setcurrentpoint (x, y) +float x, y; +#endif +{ + /* + sets the current point in the Type 1 format *BuildChar* to (x, y) in + absolute character space coordinates without performing a charstring + *moveto* command. This establishes the current point for a subsequent + relative path building command. The *setcurrentpoint* command is used + only in conjunction with results from *OtherSubrs* procedures. + */ + + current_point . x = x; + current_point . y = y; +} + +void process_hstem () /* hstem: |- y dy hstem (1) |- */ +{ + float y, dy; + + dy = pop (); + y = pop (); + do_hstem (y, dy); +} + + +void process_vstem () /* vstem: |- x dx vstem (3) |- */ +{ + float x, dx; + + dx = pop (); + x = pop (); + do_vstem (x, dx); +} + + +void process_vmoveto () /* vmoveto: |- dy vmoveto (4) |- */ +{ + float dy; + + dy = pop (); + if (active_flex) do_moveto_for_flex (0.0, dy); + else do_vmoveto (dy); +} + +void process_rlineto () /* rlineto: |- dx dy rlineto (5) |- */ +{ + float dx, dy; + + dy = pop (); + dx = pop (); + do_rlineto (dx, dy); +} + +void process_hlineto () /* hlineto: |- dx hlineto (6) |- */ +{ + float dx; + + dx = pop (); + do_hlineto (dx); +} + +void process_vlineto () /* vlineto: |- dy vlineto (7) |- */ +{ + do_vlineto (pop ()); +} + +void process_rrcurveto () /* rrcurveto: |- dx1 dy1 dx2 dy2 dx3 dy3 rrcurveto (8) |- */ +{ + float dx1, dy1, dx2, dy2, dx3, dy3; + + dy3 = pop (); + dx3 = pop (); + dy2 = pop (); + dx2 = pop (); + dy1 = pop (); + dx1 = pop (); + do_rrcurveto (dx1, dy1, dx2, dy2, dx3, dy3); +} + +void process_closepath () /* - closepath (9) |- */ +{ + do_closepath (); +} + +void process_callsubr () /* subr# callsubr */ +{ + do_callsubr ((int) pop ()); +} + +void process_return () /* - return (11) - */ +{ + /* + returns from a *Subrs* array charstring subroutine (that had been + called with a *callsubr* command) and continues execution in the + calling charstring. + */ + + do_return (); +} + +void process_escape () /* escape (12) */ +{ + /* skip */; +} + +void process_hsbw () /* |- sbx wx hsbw (13) |- */ +{ + float sbx, wx; + + wx = pop (); + sbx = pop (); + do_hsbw (sbx, wx); +} + +void process_endchar () /* - endchar (14) |- */ +{ + do_endchar (); +} + +void process_rmoveto () /* |- dx dy rmoveto (21) |- */ +{ + float dx, dy; + + dy = pop (); + dx = pop (); + if (active_flex) do_moveto_for_flex (dx, dy); + else do_rmoveto (dx, dy); +} + +void process_hmoveto () /* |- dx hmoveto (22) |- */ +{ + float dx; + + dx = pop (); + if (active_flex) do_moveto_for_flex (dx, 0.0); + else do_hmoveto (dx); +} + +void process_vhcurveto () /* |- dy1 dx2 dy2 dx3 vhcurveto (30) |- */ +{ + float dy1, dx2, dy2, dx3; + + dx3 = pop (); + dy2 = pop (); + dx2 = pop (); + dy1 = pop (); + do_vhcurveto (dy1, dx2, dy2, dx3); +} + +void process_hvcurveto () /* |- dx1 dx2 dy2 dy3 hvcurveto (31) |- */ +{ + float dx1, dx2, dy2, dy3; + + dy3 = pop (); + dy2 = pop (); + dx2 = pop (); + dx1 = pop (); + do_hvcurveto (dx1, dx2, dy2, dy3); +} + +void process_dotsection () /* - dotsection (12 0) |- */ +{ + do_dotsection (); +} + +void process_vstem3 () /* |- x0 dx0 x1 dx1 x2 dx2 vstem3 (12 1) |- */ +{ + float x0, dx0, x1, dx1, x2, dx2; + + dx2 = pop (); + x2 = pop (); + dx1 = pop (); + x1 = pop (); + dx0 = pop (); + x0 = pop (); + do_vstem3 (x0, dx0, x1, dx1, x2, dx2); +} + +void process_hstem3 () /* |- y0 dy0 y1 dy1 y2 dy2 hstem3 (12 2) |- */ +{ + float y0, dy0, y1, dy1, y2, dy2; + + dy2 = pop (); + y2 = pop (); + dy1 = pop (); + y1 = pop (); + dy0 = pop (); + y0 = pop (); + do_hstem3 (y0, dy0, y1, dy1, y2, dy2); +} + +void process_seac () /* |- asb adx ady bchar achar seac (12 6) |- */ +{ + float asb, adx, ady; + int bchar, achar; + + achar = (int) pop (); + bchar = (int) pop (); + ady = pop (); + adx = pop (); + asb = pop (); + do_seac (asb, adx, ady, bchar, achar); +} + +void process_sbw () /* |- sbx sby wx wy sbw (12 7) |- */ +{ + float sbx, sby, wx, wy; + + wy = pop (); + wx = pop (); + sby = pop (); + sbx = pop (); + do_sbw (sbx, sby, wx, wy); +} + +void process_div () /* num1 num2 div (12 12) quotient */ +{ + float num1, num2; + + num2 = pop (); + num1 = pop (); + do_div (num1, num2); +} + +void process_callothersubr () /* arg1 ... argn n othersubr# callothersubr (12 16) - */ +{ + int othersubr, n; + + othersubr = (int) pop (); + n = (int) pop (); + do_callothersubr (othersubr, n); +} + +float process_pop () +{ + return (do_pop ()); +} + +void process_setcurrentpoint () /* |- x y setcurrentpoint (12 33) |- */ +{ + float x, y; + + y = pop (); + x = pop (); + do_setcurrentpoint (x, y); +} + + +#ifdef __STDC__ +void start_char (char * name) +#else +void start_char (name) +char * name; +#endif +{ + AFM_info_tp * ai; + + ai = find_AFM_info_for (name); + if (ai == NULL || ai -> TeX_num == -1) + { +/* fprintf (stderr, "No TeX coding found for character %s\n", + name); */ + eat_this_character (name); + return; + } + if (first_time_generating) + { + fprintf (stderr, "Generating MF code for %s", name); + linepos = strlen ("Generating MF code for "); + linepos += strlen (name); + first_time_generating = FALSE; + } + else + { + if (linepos + strlen (name) + 3 < 79) + { + fprintf (stderr, ", %s", name); + linepos += strlen (name) + 3; + } + else + { + fprintf (stderr, ",\n %s", name); + linepos = strlen (name) + 2; + } + } + fprintf (mf_file, "\nbeginchar(%d,%d*FX#,%d*FY#,%d*FY#);\n", + ai -> TeX_num, ai -> width, ai -> bbox_ury, + (ai -> bbox_lly == 0) ? 0 : -ai -> bbox_lly); + fprintf (mf_file, "\"%s\";\n", ai -> AFM_name); + path_number = 0; active_path = FALSE; + ai -> in_MF_file = TRUE; + current_AFM_num = ai -> AFM_num; +} + +Subrs_entry_tp * new_Subrs_entry () +{ + Subrs_entry_tp * nse; + + nse = (Subrs_entry_tp *) my_malloc (sizeof (Subrs_entry_tp)); + nse -> token = NULL; + nse -> next = NULL; + return (nse); +} + +void process_one_Subrs_entry () +{ + Subrs_entry_tp * se, * nse, * lse; + char * p; + int n; + bool stop; + + stop = FALSE; + expect ("dup"); + n = param_num (); + if (n >= MAX_Subrs_entries) error ("! Too many Subrs"); + se = new_Subrs_entry (); + lse = se; + while (! stop) + { + nse = new_Subrs_entry (); + nse -> token = param_new_string (); + if (strequ (nse -> token, "return")) stop = TRUE; + lse -> next = nse; + lse = nse; + if (! * param) get_line (ps_file); + } + Subrs_entries [n] = se; +} + +void process_Subrs_entries () +{ + int i; + + while (get_line (ps_file)) + { + if (strstr (obuffer, "dup") == NULL) return; + else process_one_Subrs_entry (); + } +} + +void get_paint_type () +{ + char * dummy_string; + int dummy_int; + + dummy_string = param_string (); + dummy_int = param_num (); + if (dummy_int != 0) error ("! Can only handle outlinefonts"); +} + +void get_font_type () +{ + char * dummy_string; + int dummy_int; + + dummy_string = param_string (); + dummy_int = param_num (); + if (dummy_int != 1) error ("! Can only translate Type 1 fonts"); +} + +void get_font_matrix () +{ + char * dummy_string; + float dummy_float; + + dummy_string = param_string (); + if (* param == '[') + { + param ++; + while (* param == ' ') param ++; + } + x_scale = param_float (); + dummy_float = param_float (); + dummy_float = param_float (); + y_scale = param_float (); +} + +void get_italic_angle () +{ + char * dummy_string; + float dummy_float; + + dummy_string = param_string (); + if (italic_angle != param_float ()) + { + error ("! PS en AFM do not match"); + } +} + +void get_is_fixed_pitch () +{ + char * dummy_string; + + dummy_string = param_string (); + if (fixed_pitch != ((* param == 't' || * param == 'T') ? TRUE : FALSE)) + { + error ("! PS en AFM do not match"); + } +} + +void get_blue_scale () +{ + char * dummy_string; + float dummy_float; + int dummy_int; + + dummy_string = param_string (); + blue_scale = param_float (); +} + +void get_blue_shift () +{ + char * dummy_string; + float dummy_float; + int dummy_int; + + dummy_string = param_string (); + blue_shift = param_num (); +} + +void get_blue_fuzz () +{ + char * dummy_string; + float dummy_float; + int dummy_int; + + dummy_string = param_string (); + blue_fuzz = param_num (); +} + +void get_blue_values () +{ + char * dummy_string; + + num_of_blue_values = 0; + dummy_string = param_string (); + if (* param == '[') + { + param ++; + while (* param == ' ') param ++; + } + while (isdigit (* param) || * param == '-') /* added ILH */ + { + if (num_of_blue_values == 0) + { + blue_values [num_of_blue_values] . overshoot + = param_num (); + blue_values [num_of_blue_values] . position + = param_num (); + } + else + { + blue_values [num_of_blue_values] . position + = param_num (); + blue_values [num_of_blue_values] . overshoot + = param_num (); + } + num_of_blue_values ++; +/* if (num_of_blue_values >= MAX_blue_values) */ + } +} + +void get_other_blues () +{ + char * dummy_string; + float dummy_float; + int dummy_int; + + num_of_other_blues = 0; + dummy_string = param_string (); + if (* param == '[') + { + param ++; + while (* param == ' ') param ++; + } + while (isdigit (* param) || * param == '-') /* added ILH */ + { + other_blues [num_of_other_blues] . overshoot = param_num (); + other_blues [num_of_other_blues] . position = param_num (); + num_of_other_blues ++; +/* if (num_of_other_blues >= MAX_other_blues) */ + } +} + +void parse_PS_header () +{ + /* Skip PS file until FontInfo entry -- the FontInfo case below will + not be called because we eat it now */ + while (get_line (ps_file) && PS_header_command () != FontInfo) + /* skip */; + while (get_line (ps_file)) + { + switch (PS_header_command ()) + { + case FontInfo: break; + case FontName: break; + case Encoding: break; + case PaintType: + { + get_paint_type (); + } + break; + case FontType: + { + get_font_type (); + } + break; + case FontMatrix: + { + get_font_matrix (); + } + break; + case FontBBox: break; + case UniqueID: break; + case Metrics: break; + case StrokeWidth: break; + case Private: break; + case CharStrings: + { + get_line (ps_file); + return; + } + case FID: break; + case version: break; + case Notice: break; + case FullName: break; + case FamilyName: break; + case Weight: break; + case ItalicAngle: + { + get_italic_angle (); + } + break; + case isFixedPitch: + { + get_is_fixed_pitch (); + } + break; + case UnderlinePosition: break; + case UnderlineThickness: break; + case BlueFuzz: + { + get_blue_fuzz (); + } + break; + case BlueScale: + { + get_blue_scale (); + } + break; + case BlueShift: + { + get_blue_shift (); + } + break; + case BlueValues: + { + get_blue_values (); + } + break; + case ExpansionFactor: break; + case FamilyBlues: break; + case FamilyOtherBlues: break; + case ForceBold: break; + case LanguageGroup: break; + case lenIV: break; + case MinFeature: break; + case ND: break; + case NP: break; + case OtherSubrs: break; + case OtherBlues: + { + get_other_blues (); + } + break; + case password: break; + case RD: break; + case RndStemUp: break; + case StdHW: break; + case StdVW: break; + case StemSnapH: break; + case StemSnapV: break; + case Subrs: + { + process_Subrs_entries (); + } + break; + case not_a_PS_header_command: break; + default: break; + } + } +} + +char * next_param_string () +{ + if (! processing_Subr) return (param_string ()); + Subrs_stack [current_Subr] = Subrs_stack [current_Subr] -> next; + return (Subrs_stack [current_Subr] -> token); +} + +void parse_charstrings_dictionary () +{ + float dummy; + + processing_Subr = FALSE; + current_Subr = -1; + while (get_token (ps_file)) + { + switch (charstring_command (next_param_string ())) + { + case hstem: process_hstem (); break; + case vstem: process_vstem (); break; + case vmoveto: process_vmoveto (); break; + case rlineto: process_rlineto (); break; + case hlineto: process_hlineto (); break; + case vlineto: process_vlineto (); break; + case rrcurveto: process_rrcurveto (); break; + case closepath: process_closepath (); break; + case callsubr: process_callsubr (); break; + case return_command: process_return (); break; + case escape: process_escape (); break; + case hsbw: process_hsbw (); break; + case endchar: process_endchar (); break; + case rmoveto: process_rmoveto (); break; + case hmoveto: process_hmoveto (); break; + case vhcurveto: process_vhcurveto (); break; + case hvcurveto: process_hvcurveto (); break; + case dotsection: process_dotsection (); break; + case vstem3: process_vstem3 (); break; + case hstem3: process_hstem3 (); break; + case seac: process_seac (); break; + case sbw: process_sbw (); break; + case div: process_div (); break; + case callothersubr: process_callothersubr (); + break; + case pop_command: dummy = process_pop (); break; + case charstring_command_numeric: + push (numeric_val); break; + case charstring_command_char: + start_char (current_char); + break; + case charstring_commands_end: return; + default: break; + } + } +} + +void parse_PS () +{ + top_of_stack = 0; + x_scale = 1000; y_scale = 1000; + have_found_seacs = FALSE; after_hint = FALSE; + the_sbx = 0.0; + blue_scale = 0.039625; blue_shift = 7; blue_fuzz = 1; + first_time_generating = TRUE; + parse_PS_header (); + write_MF_header (); + charstring_position = ftell (ps_file); + processing_seacs = FALSE; + parse_charstrings_dictionary (); + if (have_found_seacs) + { + fseek (ps_file, charstring_position, 0); + processing_seacs = TRUE; + parse_charstrings_dictionary (); + } + fprintf (stderr, ".\n"); + process_ligatures_and_kerns (); + write_MF_trailer (); +} diff --git a/fonts/utilities/ps2mf/PSparse.h b/fonts/utilities/ps2mf/PSparse.h new file mode 100644 index 0000000000..75c5c0a0b7 --- /dev/null +++ b/fonts/utilities/ps2mf/PSparse.h @@ -0,0 +1,335 @@ +/* PSparse.h */ + +char * PS_header_commands [] = +{ + "/FontInfo", + "/FontName", + "/Encoding", + "/PaintType", + "/FontType", + "/FontMatrix", + "/FontBBox", + "/UniqueID", + "/Metrics", + "/StrokeWidth", + "/Private", + "/CharStrings", + "/FID", + "/version", + "/Notice", + "/FullName", + "/FamilyName", + "/Weight", + "/ItalicAngle", + "/isFixedPitch", + "/UnderlinePosition", + "/UnderlineThickness", + "/BlueFuzz", + "/BlueScale", + "/BlueShift", + "/BlueValues", + "/ExpansionFactor", + "/FamilyBlues", + "/FamilyOtherBlues", + "/ForceBold", + "/LanguageGroup", + "/lenIV", + "/MinFeature", + "/ND", + "/NP", + "/OtherBlues", + "/OtherSubrs", + "/password", + "/RD", + "/RndStemUp", + "/StdHW", + "/StdVW", + "/StemSnapH", + "/StemSnapV", + "/Subrs", + NULL +}; + +#define FontInfo (0) +#define FontName (1) +#define Encoding (2) +#define PaintType (3) +#define FontType (4) +#define FontMatrix (5) +#define FontBBox (6) +#define UniqueID (7) +#define Metrics (8) +#define StrokeWidth (9) +#define Private (10) +#define CharStrings (11) +#define FID (12) +#define version (13) +#define Notice (14) +#define FullName (15) +#define FamilyName (16) +#define Weight (17) +#define ItalicAngle (18) +#define isFixedPitch (19) +#define UnderlinePosition (20) +#define UnderlineThickness (21) +#define BlueFuzz (22) +#define BlueScale (23) +#define BlueShift (24) +#define BlueValues (25) +#define ExpansionFactor (26) +#define FamilyBlues (27) +#define FamilyOtherBlues (28) +#define ForceBold (29) +#define LanguageGroup (30) +#define lenIV (31) +#define MinFeature (32) +#define ND (33) +#define NP (34) +#define OtherBlues (35) +#define OtherSubrs (36) +#define password (37) +#define RD (38) +#define RndStemUp (39) +#define StdHW (40) +#define StdVW (41) +#define StemSnapH (42) +#define StemSnapV (43) +#define Subrs (44) +#define not_a_PS_header_command (-1) + +char * charstring_commands [] = +{ + "hstem", + "vstem", + "vmoveto", + "rlineto", + "hlineto", + "vlineto", + "rrcurveto", + "closepath", + "callsubr", + "return", + "escape", + "hsbw", + "endchar", + "rmoveto", + "hmoveto", + "vhcurveto", + "hvcurveto", + "dotsection", + "vstem3", + "hstem3", + "seac", + "sbw", + "div", + "callothersubr", + "pop", + "setcurrentpoint", + NULL +}; + +#define hstem (0) +#define vstem (1) +#define vmoveto (2) +#define rlineto (3) +#define hlineto (4) +#define vlineto (5) +#define rrcurveto (6) +#define closepath (7) +#define callsubr (8) +#define return_command (9) /* return is a reserved word !!!! */ +#define escape (10) +#define hsbw (11) +#define endchar (12) +#define rmoveto (13) +#define hmoveto (14) +#define vhcurveto (15) +#define hvcurveto (16) +#define dotsection (17) +#define vstem3 (18) +#define hstem3 (19) +#define seac (20) +#define sbw (21) +#define div (22) +#define callothersubr (23) +#define pop_command (24) +#define setcurrentpoint (25) +#define not_a_charstring_command (-1) +#define charstring_command_numeric (-2) +#define charstring_command_char (-3) +#define charstring_commands_end (-4) + +char * seac_candidates [] = +{ + "A", + "C", + "E", + "I", + "N", + "O", + "S", + "U", + "Y", + "Z", + "a", + "c", + "dotlessi", + "e", + "n", + "o", + "s", + "u", + "y", + "z", + "acute", + "caron", + "cedilla", + "circumflex", + "dieresis", + "grave", + "ring", + "tilde", + NULL +}; + +#define MAX_Subrs_entries 1000 /* Really I have seen a font with 612 entries */ +#define MAX_Subrs_stack 11 +bool processing_Subr; +int current_Subr; + +typedef struct Subrs_entry +{ + char * token; + struct Subrs_entry * next; +} Subrs_entry_tp; +Subrs_entry_tp * Subrs_entries [MAX_Subrs_entries], + * Subrs_stack [MAX_Subrs_stack]; + +char coding_vector [255][35]; + +#define MAX_stack 1500 +float stack [MAX_stack]; +int top_of_stack; +float numeric_val; +char current_char [35]; +int current_AFM_num; +bool after_hint; +float the_sbx; + +int active_path, path_number; +bool active_flex; +typedef struct Flex +{ + float x [7], y [7]; + int n; +} Flex_tp; +Flex_tp flex; +typedef struct cartesian +{ + float x; + float y; +} cartesian_tp; +cartesian_tp current_point; +bool processing_seacs, have_found_seacs; +long charstring_position; + +#define MAX_blue_values 7 +#define MAX_other_blues 5 +typedef struct blue_pairs +{ + int overshoot; + int position; +} blue_pairs_tp; +blue_pairs_tp blue_values [MAX_blue_values], other_blues [MAX_other_blues]; +int num_of_blue_values, num_of_other_blues; +float blue_scale; +int blue_shift; +int blue_fuzz; + +bool first_time_generating; +int linepos; + +#ifndef __P +#ifdef __STDC__ +#define __P(a) a +#else +#define __P(a) () +#endif +#endif + +bool candidate_for_seac __P((void)); +int charstring_command __P((char * s)); +void do_callothersubr __P((int othersubr, int n)); +void do_callsubr __P((int subr_no)); +void do_closepath __P((void)); +void do_div __P((float num1, float num2)); +void do_dotsection __P((void)); +void do_endchar __P((void)); +void do_hlineto __P((float dx)); +void do_hmoveto __P((float dx)); +void do_hsbw __P((float sbx, float wx)); +void do_hstem __P((float y, float dy)); +void do_hstem3 __P((float y0, float dy0, float y1, float dy1, float y2, + float dy2)); +void do_hvcurveto __P((float dx1, float dx2, float dy2, float dy3)); +float do_pop __P((void)); +void do_rcurveto __P((float dx1, float dy1, float dx2, float dy2, float dx3, + float dy3)); +void do_return __P((void)); +void do_rlineto __P((float dx, float dy)); +void do_rmoveto __P((float dx, float dy)); +void do_rrcurveto __P((float dx1, float dy1, float dx2, float dy2, float dx3, + float dy3)); +void do_sbw __P((float sbx, float sby, float wx, float wy)); +void do_seac __P((float asb, float adx, float ady, int bchar, int achar)); +void do_setcurrentpoint __P((float x, float y)); +void do_vhcurveto __P((float dy1, float dx2, float dy2, float dx3)); +void do_vlineto __P((float dy)); +void do_vmoveto __P((float dy)); +void do_vstem __P((float x, float dx)); +void do_vstem3 __P((float x0, float dx0, float x1, float dx1, float x2, + float dx2)); +void eat_this_character __P((char * s)); +void get_blue_scale __P((void)); +void get_blue_values __P((void)); +void get_font_matrix __P((void)); +void get_font_type __P((void)); +void get_is_fixed_pitch __P((void)); +void get_italic_angle __P((void)); +void get_other_blues __P((void)); +void get_paint_type __P((void)); +Subrs_entry_tp * new_Subrs_entry __P((void)); +char * next_param_string __P((void)); +void parse_PS_header __P((void)); +void parse_charstrings_dictionary __P((void)); +float pop __P((void)); +void process_callothersubr __P((void)); +void process_callsubr __P((void)); +void process_closepath __P((void)); +void process_div __P((void)); +void process_dotsection __P((void)); +void process_endchar __P((void)); +void process_escape __P((void)); +void process_hlineto __P((void)); +void process_hmoveto __P((void)); +void process_hsbw __P((void)); +void process_hstem __P((void)); +void process_hstem3 __P((void)); +void process_hvcurveto __P((void)); +void process_one_Subrs_entry __P((void)); +float process_pop __P((void)); +void process_return __P((void)); +void process_rlineto __P((void)); +void process_rmoveto __P((void)); +void process_rrcurveto __P((void)); +void process_sbw __P((void)); +void process_seac __P((void)); +void process_setcurrentpoint __P((void)); +void process_Subrs_entries __P((void)); +void process_vhcurveto __P((void)); +void process_vlineto __P((void)); +void process_vmoveto __P((void)); +void process_vstem __P((void)); +void process_vstem3 __P((void)); +void push __P((float fl)); +void start_char __P((char * name)); diff --git a/fonts/utilities/ps2mf/alloca.c b/fonts/utilities/ps2mf/alloca.c new file mode 100644 index 0000000000..cfe98f92d2 --- /dev/null +++ b/fonts/utilities/ps2mf/alloca.c @@ -0,0 +1,191 @@ +/* + alloca -- (mostly) portable public-domain implementation -- D A Gwyn + + last edit: 86/05/30 rms + include config.h, since on VMS it renames some symbols. + Use xmalloc instead of malloc. + + This implementation of the PWB library alloca() function, + which is used to allocate space off the run-time stack so + that it is automatically reclaimed upon procedure exit, + was inspired by discussions with J. Q. Johnson of Cornell. + + It should work under any C implementation that uses an + actual procedure stack (as opposed to a linked list of + frames). There are some preprocessor constants that can + be defined when compiling for your specific system, for + improved efficiency; however, the defaults should be okay. + + The general concept of this implementation is to keep + track of all alloca()-allocated blocks, and reclaim any + that are found to be deeper in the stack than the current + invocation. This heuristic does not reclaim storage as + soon as it becomes invalid, but it will do so eventually. + + As a special case, alloca(0) reclaims storage without + allocating any. It is a good idea to use alloca(0) in + your main control loop, etc. to force garbage collection. +*/ +#ifndef lint +static char SCCSid[] = "@(#)alloca.c 1.1"; /* for the "what" utility */ +#endif + +#ifdef emacs +#include "config.h" +#ifdef static +/* actually, only want this if static is defined as "" + -- this is for usg, in which emacs must undefine static + in order to make unexec workable + */ +#ifndef STACK_DIRECTION +you +lose +-- must know STACK_DIRECTION at compile-time +#endif /* STACK_DIRECTION undefined */ +#endif static +#endif emacs + +#ifdef X3J11 +typedef void *pointer; /* generic pointer type */ +#else +typedef char *pointer; /* generic pointer type */ +#endif + +#define NULL 0 /* null pointer constant */ + +extern void free(); +extern pointer xmalloc(); + +/* + Define STACK_DIRECTION if you know the direction of stack + growth for your system; otherwise it will be automatically + deduced at run-time. + + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown +*/ + +#ifndef STACK_DIRECTION +#define STACK_DIRECTION 0 /* direction unknown */ +#endif + +#if STACK_DIRECTION != 0 + +#define STACK_DIR STACK_DIRECTION /* known at compile-time */ + +#else /* STACK_DIRECTION == 0; need run-time code */ + +static int stack_dir; /* 1 or -1 once known */ +#define STACK_DIR stack_dir + +static void +find_stack_direction (/* void */) +{ + static char *addr = NULL; /* address of first + `dummy', once known */ + auto char dummy; /* to get stack address */ + + if (addr == NULL) + { /* initial entry */ + addr = &dummy; + + find_stack_direction (); /* recurse once */ + } + else /* second entry */ + if (&dummy > addr) + stack_dir = 1; /* stack grew upward */ + else + stack_dir = -1; /* stack grew downward */ +} + +#endif /* STACK_DIRECTION == 0 */ + +/* + An "alloca header" is used to: + (a) chain together all alloca()ed blocks; + (b) keep track of stack depth. + + It is very important that sizeof(header) agree with malloc() + alignment chunk size. The following default should work okay. +*/ + +#ifndef ALIGN_SIZE +#define ALIGN_SIZE sizeof(double) +#endif + +typedef union hdr +{ + char align[ALIGN_SIZE]; /* to force sizeof(header) */ + struct + { + union hdr *next; /* for chaining headers */ + char *deep; /* for stack depth measure */ + } h; +} header; + +/* + alloca( size ) returns a pointer to at least `size' bytes of + storage which will be automatically reclaimed upon exit from + the procedure that called alloca(). Originally, this space + was supposed to be taken from the current stack frame of the + caller, but that method cannot be made to work for some + implementations of C, for example under Gould's UTX/32. +*/ + +static header *last_alloca_header = NULL; /* -> last alloca header */ + +pointer +alloca (size) /* returns pointer to storage */ + unsigned size; /* # bytes to allocate */ +{ + auto char probe; /* probes stack depth: */ + register char *depth = &probe; + +#if STACK_DIRECTION == 0 + if (STACK_DIR == 0) /* unknown growth direction */ + find_stack_direction (); +#endif + + /* Reclaim garbage, defined as all alloca()ed storage that + was allocated from deeper in the stack than currently. */ + + { + register header *hp; /* traverses linked list */ + + for (hp = last_alloca_header; hp != NULL;) + if (STACK_DIR > 0 && hp->h.deep > depth + || STACK_DIR < 0 && hp->h.deep < depth) + { + register header *np = hp->h.next; + + free ((pointer) hp); /* collect garbage */ + + hp = np; /* -> next header */ + } + else + break; /* rest are not deeper */ + + last_alloca_header = hp; /* -> last valid storage */ + } + + if (size == 0) + return NULL; /* no allocation required */ + + /* Allocate combined header + user data storage. */ + + { + register pointer new = xmalloc (sizeof (header) + size); + /* address of header */ + + ((header *)new)->h.next = last_alloca_header; + ((header *)new)->h.deep = depth; + + last_alloca_header = (header *)new; + + /* User storage begins just after header. */ + + return (pointer)((char *)new + sizeof(header)); + } +} + diff --git a/fonts/utilities/ps2mf/chr2ps.c b/fonts/utilities/ps2mf/chr2ps.c new file mode 100644 index 0000000000..0e78ea1c25 --- /dev/null +++ b/fonts/utilities/ps2mf/chr2ps.c @@ -0,0 +1,350 @@ +/* CHR2PS.C */ + +#define VERSION "1.0 (beta)" + +#include <stdio.h> +#include <string.h> +#ifndef AIX +#include <stdlib.h> +#endif +#include "defines.h" +#include "myopen.h" +#include "chr2ps.h" + +void give_usage () +{ + fprintf (stderr, "Usage: chr2ps [<somechr[.chr]|-]"); + fprintf (stderr, " [<someps>[.ps]]\n"); + exit (UNSUCCESSFUL); +} + +#ifdef __STDC__ +void preamble (int argc, char ** argv) +#else +void preamble (argc, argv) +int argc; +char ** argv; +#endif +{ + if (argc == 1) give_usage (); + if (argc == 3) + { + if (strequ (argv [1], "-")) chr_file = stdin; + else chr_file = my_open (argv [1], ".chr", "rb"); + ps_file = my_open (argv [2], ".ps", "w"); + } + else + { + chr_file = my_open (argv [1], ".chr", "rb"); + ps_file = my_open (argv [1], ".ps", "w"); + } +} + +void postamble () +{ + fclose (chr_file); + fclose (ps_file); + fprintf (stderr, "Conversion done\n"); + exit (SUCCESSFUL); +} + +#ifdef __STDC__ +unsigned char ReadChar (void) +#else +unsigned char ReadChar () +#endif +{ + char Inc; + + if (! HaveSavedChar) + { + fread (&Inc, 1, 1, chr_file); + /* translate CR, LF or CR/LF to '\n' */ + if (Inc == '\r') /* CR = 0x0D */ + { + fread (&Inc, 1, 1, chr_file); + if (Inc != '\n') /* LF = 0x0A */ + { + HaveSavedChar = TRUE; + SavedChar = Inc; + } + Inc = '\n'; + } + } + else + { + Inc = SavedChar; + HaveSavedChar = FALSE; + } + return (Inc); +} + +#ifdef __STDC__ +void ReadLine (void) +#else +void ReadLine () +#endif +{ +/* read another line (binary mode!) + do not include the \r and \n characters + */ +/* assume a line is terminated by CR, LF or CR/LF */ + + char_pos = in_buff; + * in_buff = NULLCHAR; + in_size = 0; + while (! feof (chr_file)) + { + inchar = ReadChar (); + if (inchar != '\n') + { + in_buff [in_size] = inchar; + in_size++; + } + else + { + break; + } + } + in_buff [in_size] = NULLCHAR; +} + +#ifdef __STDC__ +unsigned char DeCrypt (unsigned char cipher) +#else +unsigned char DeCrypt(cipher) +unsigned char cipher; +#endif +{ + unsigned char plain; + + plain = (cipher ^ (cr >> 8)); + cr = (cipher + cr) * cc1 + cc2; + return plain; +} + +#ifdef __STDC__ +void DecryptCharString (unsigned char * CS, int count) +#else +void DecryptCharString (CS, count) +unsigned char * CS; +int count; +#endif +{ + int i; + unsigned char byte; + long value; + int out_size; + + cr = CR; cc1 = CC1; cc2 = CC2; + out_size = 0; + fputs("{ ", ps_file); + for (i = 0; i < lenIV; i++) byte = DeCrypt (CS [i]); + for (i = lenIV ; i < count ; ) + { + byte = DeCrypt (CS [i ++]); + if (byte == 11) + { + fprintf (ps_file, " %s", commands [byte] . command); + break; + } + else if (byte == 12) + { + byte = DeCrypt (CS [i ++]); + if (byte > MAX_ESCAPE) + { + out_size = out_size + 17; + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + fprintf (ps_file, " not_defined_e%d", byte); + } + else + { + out_size = out_size + + strlen (escapes [byte] . command); + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + fprintf (ps_file, " %s", + escapes [byte] . command); + } + continue; + } + else if (byte < 32) + { + out_size = out_size + + strlen (commands [byte] . command); + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + fprintf (ps_file, " %s", commands [byte] . command); + } + if (byte >= 32) + { + if (byte <= 246) + { + out_size = out_size + 4; + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + fprintf (ps_file, " %d", byte - 139); + } + else if ((byte >= 247) && (byte <= 250)) + { + out_size = out_size + 7; + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + fprintf (ps_file, " %d", (byte - 247) * 256 + + DeCrypt (CS [i ++]) + 108); + } + else if ((byte >= 251) && (byte <= 254)) + { + out_size = out_size + 7; + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + fprintf (ps_file, " %d", -(byte - 251) * 256 + - DeCrypt(CS[i++]) - 108); + } + else if (byte == 255) + { + out_size = out_size + 9; + if (out_size > out_break) + { + out_size = 0; + fprintf (ps_file, "\n "); + } + value = DeCrypt (CS [i ++]); + value <<= 8; + value += DeCrypt (CS [i ++]); + value <<= 8; + value += DeCrypt (CS [i ++]); + value <<= 8; + value += DeCrypt (CS [i ++]); + fprintf (ps_file, " %d", value); + } + } + } + fprintf (ps_file, " } "); +} + +#ifdef __STDC__ +void main (int argc, char ** argv) +#else +void main(argc, argv) +int argc; +char ** argv; +#endif +{ + int lusteller; + char ch; + + fprintf (stderr, "This is chr2ps, version: %s\n", VERSION); + preamble (argc, argv); + HaveSavedChar = FALSE; in_size = 0; + fprintf (stderr, " Conversion of charstring to postscript \n"); + fprintf (stderr, " Copying inputfile until /Subrs entry \n"); + for (;;) + { + ReadLine (); + fprintf (ps_file, "%s\n", in_buff); + if (strnequ ((char *) in_buff, "/lenIV", 6)) + { + lenIV = atoi ((char *) in_buff + 7); + } + if (strstr ((char *) in_buff, "/Subrs") != NULL) break; + } + tp = 0; in_size = 0; inchar= ' '; + fprintf (stderr, " Decrypting charstring data now (This may take a while...)\n"); + for (lusteller = 0;; lusteller ++) + { + if (! (lusteller % 20)) fprintf (stderr, "."); + if (feof (chr_file)) break; + prevchar = inchar; + inchar = ReadChar (); + in_size ++; + if (in_size > TEMPSIZE) fputc (temp_buff [tp], ps_file); + temp_buff [tp] = inchar; + if (tp == (TEMPSIZE - 1)) tp = 0; + else tp++; + if ((inchar != '-') && (inchar != 'R')) continue; + if (prevchar != ' ') continue; + if (inchar == '-') testchar = '|'; + else testchar = 'D'; + inchar = ReadChar (); + if (inchar != testchar) + { + in_size++; + if (in_size > TEMPSIZE) fputc (temp_buff [tp], ps_file); + temp_buff[tp] = inchar; + if (tp == (TEMPSIZE - 1)) tp = 0; + else tp++; + continue; + } + inchar = ReadChar (); + testchar = ' '; + if (inchar != testchar) + { + in_size++; + if (in_size > TEMPSIZE) fputc (temp_buff [tp], ps_file); + temp_buff [tp] = inchar; + if (tp == (TEMPSIZE - 1)) tp = 0; + else tp++; + continue; + } + if (in_size > 20) restcount = 20; + else + { + restcount = in_size; + tp = 0; + } + for (i = 0 ; i < restcount ; i++) + { + in_buff [i] = temp_buff [tp]; + if (tp == (TEMPSIZE - 1)) tp = 0; + else tp++; + } + in_buff [restcount] = NULLCHAR; + count_pos = & in_buff [restcount - 2]; + do count_pos --; + while (* count_pos != ' '); + count_pos ++; + count = atoi ((char *) count_pos); + * count_pos = NULLCHAR; + fprintf (ps_file, "%s", in_buff); + in_size = 0; tp = 0; + fread (CharString, 1, count, chr_file); + CharString [count] = NULLCHAR; + DecryptCharString (CharString, count); + } + fprintf (stderr, "\n"); + if (in_size > 20) restcount = 20; + else + { + restcount = in_size; + tp = 0; + } + for (i = 0 ; i < restcount ; i ++) + { + in_buff [i] = temp_buff [tp]; + if (tp == (TEMPSIZE - 1)) tp = 0; + else tp++; + } + in_buff [restcount] = NULLCHAR; + fprintf (ps_file, "%s", in_buff); + postamble (); +} diff --git a/fonts/utilities/ps2mf/chr2ps.h b/fonts/utilities/ps2mf/chr2ps.h new file mode 100644 index 0000000000..c8d66c74ea --- /dev/null +++ b/fonts/utilities/ps2mf/chr2ps.h @@ -0,0 +1,112 @@ +/* chr2ps.h */ + +int lenIV = 4; /* CharString salt length */ + +typedef struct +{ + char * command; + int value; +} Command; + +Command commands [] = +{ + { "notdefined_c0", 0 }, + { "hstem", 1 }, + { "notdefined_c2", 2 }, + { "vstem", 3 }, + { "vmoveto", 4 }, + { "rlineto", 5 }, + { "hlineto", 6 }, + { "vlineto", 7 }, + { "rrcurveto", 8 }, + { "closepath", 9 }, + { "callsubr", 10 }, + { "return", 11 }, + { "escape", 12 }, + { "hsbw", 13 }, + { "endchar", 14 }, + { "notdefined_c15", 15 }, + { "notdefined_c16", 16 }, + { "notdefined_c17", 17 }, + { "notdefined_c18", 18 }, + { "notdefined_c19", 19 }, + { "notdefined_c20", 20 }, + { "rmoveto", 21 }, + { "hmoveto", 22 }, + { "notdefined_c23", 23 }, + { "notdefined_c24", 24 }, + { "notdefined_c25", 25 }, + { "notdefined_c26", 26 }, + { "notdefined_c27", 27 }, + { "notdefined_c28", 28 }, + { "notdefined_c29", 29 }, + { "vhcurveto", 30 }, + { "hvcurveto", 31 } +}; + +Command escapes[] = +{ + { "dotsection", 0 }, + { "vstem3", 1 }, + { "hstem3", 2 }, + { "notdefined_e3", 3 }, + { "notdefined_e4", 4 }, + { "notdefined_e5", 5 }, + { "seac", 6 }, + { "sbw", 7 }, + { "notdefined_e8", 8 }, + { "notdefined_e9", 9 }, + { "notdefined_e10", 10 }, + { "notdefined_e11", 11 }, + { "div", 12 }, + { "notdefined_e13", 13 }, + { "notdefined_e14", 14 }, + { "notdefined_e15", 15 }, + { "callothersubr", 16 }, + { "pop", 17 }, + { "notdefined_e18", 18 }, + { "notdefined_e19", 19 }, + { "notdefined_e20", 20 }, + { "notdefined_e21", 21 }, + { "notdefined_e22", 22 }, + { "notdefined_e23", 23 }, + { "notdefined_e24", 24 }, + { "notdefined_e25", 25 }, + { "notdefined_e26", 26 }, + { "notdefined_e27", 27 }, + { "notdefined_e28", 28 }, + { "notdefined_e29", 29 }, + { "notdefined_e30", 30 }, + { "notdefined_e31", 31 }, + { "notdefined_e32", 32 }, + { "setcurrentpoint", 33 } +}; + +#define MAX_ESCAPE 33 + +#define CR 4330 +#define CC1 52845 +#define CC2 22719 + +#define CHARSIZE 4000 +#define LINESIZE 4000 +#define TEMPSIZE 20 + +#define out_break 120 + + +FILE * chr_file, * ps_file; + +unsigned char HaveSavedChar = FALSE; +char SavedChar; + +unsigned short int cr, cc1, cc2; +unsigned char CharString [CHARSIZE], inchar, testchar, prevchar; +unsigned char byte, temp_buff [TEMPSIZE]; +unsigned char in_buff [LINESIZE], * char_pos, * rd_pos, * count_pos; +int in_size, rd_index, tp, btp, CP, i, copycount, count, restcount; + +unsigned char ReadChar __P((void)); +void ReadLine __P((void)); +void DecryptCharString __P((unsigned char * CS, int count)); +unsigned char DeCrypt __P((unsigned char cipher)); diff --git a/fonts/utilities/ps2mf/defines.h b/fonts/utilities/ps2mf/defines.h new file mode 100644 index 0000000000..9d0922befd --- /dev/null +++ b/fonts/utilities/ps2mf/defines.h @@ -0,0 +1,20 @@ +typedef unsigned char bool; + +#define strequ(a,b) (strcmp (a, b) == 0) +#define strnequ(a,b,c) (strncmp (a, b, c) == 0) + +#ifndef __P +#ifdef __STDC__ +#define __P(a) a +#else +#define __P(a) () +#endif +#endif + +#define UNSUCCESSFUL 1 +#define SUCCESSFUL 0 + +#define TRUE 1 +#define FALSE 0 + +#define NULLCHAR (unsigned char) 0 diff --git a/fonts/utilities/ps2mf/getopt.c b/fonts/utilities/ps2mf/getopt.c new file mode 100644 index 0000000000..da64d69b61 --- /dev/null +++ b/fonts/utilities/ps2mf/getopt.c @@ -0,0 +1,611 @@ +/* Getopt for GNU. + Copyright (C) 1987, 1989, 1990, 1991 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifdef __STDC__ +#define CONST const +#else +#define CONST +#endif + +/* This version of `getopt' appears to the caller like standard Unix `getopt' + but it behaves differently for the user, since it allows the user + to intersperse the options with the other arguments. + + As `getopt' works, it permutes the elements of `argv' so that, + when it is done, all the options precede everything else. Thus + all application programs are extended to handle flexible argument order. + + Setting the environment variable _POSIX_OPTION_ORDER disables permutation. + Then the behavior is completely standard. + + GNU application programs can use a third alternative mode in which + they can distinguish the relative order of options and other arguments. */ + +#include <stdio.h> + +/* If compiled with GNU C, use the built-in alloca */ +#ifdef __GNUC__ +#define alloca __builtin_alloca +#else /* not __GNUC__ */ +#ifdef sparc +#include <alloca.h> +#else +#ifdef _AIX +#pragma alloca +#else +# ifdef MSDOS +# include <malloc.h> +# else +char *alloca (); +# endif +#endif +#endif /* sparc */ +#endif /* not __GNUC__ */ + +#if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__) +#include <stdlib.h> +#else /* STDC_HEADERS or __GNU_LIBRARY__ */ +# ifndef MSDOS +char *getenv (); +char *malloc (); +# endif +#endif /* STDC_HEADERS or __GNU_LIBRARY__ */ + +#if defined(USG) || defined(STDC_HEADERS) || defined(__GNU_LIBRARY__) || defined (MSDOS) +#include <string.h> +#define bcopy(s, d, n) memcpy ((d), (s), (n)) +#define index strchr +#else /* USG or STDC_HEADERS or __GNU_LIBRARY__ */ +#ifdef VMS +#include <string.h> +#else /* VMS */ +#include <strings.h> +#endif /* VMS */ +/* Declaring bcopy causes errors on systems whose declarations are different. + If the declaration is omitted, everything works fine. */ +#endif /* USG or STDC_HEADERS or __GNU_LIBRARY__ */ + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +char *optarg = 0; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns EOF, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +int optind = 0; + +/* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + +static char *nextchar; + +/* Callers store zero here to inhibit the error message + for unrecognized options. */ + +int opterr = 1; + +/* Describe how to deal with options that follow non-option ARGV-elements. + + If the caller did not specify anything, + the default is REQUIRE_ORDER if the environment variable + _POSIX_OPTION_ORDER is defined, PERMUTE otherwise. + + REQUIRE_ORDER means don't recognize them as options; + stop option processing when the first non-option is seen. + This is what Unix does. + This mode of operation is selected by either setting the environment + variable _POSIX_OPTION_ORDER, or using `+' as the first character + of the list of option characters. + + PERMUTE is the default. We permute the contents of ARGV as we scan, + so that eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written to + expect this. + + RETURN_IN_ORDER is an option available to programs that were written + to expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. + Using `-' as the first character of the list of option characters + selects this mode of operation. + + The special argument `--' forces an end of option-scanning regardless + of the value of `ordering'. In the case of RETURN_IN_ORDER, only + `--' can cause `getopt' to return EOF with `optind' != ARGC. */ + +static enum +{ + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER +} ordering; + +/* Describe the long-named options requested by the application. + _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an + element containing a name which is zero. + The field `has_arg' is 1 if the option takes an argument, + 2 if it takes an optional argument. */ + +struct option +{ + char *name; + int has_arg; + int *flag; + int val; +}; + +CONST struct option *_getopt_long_options; + +int _getopt_long_only = 0; + +/* Index in _GETOPT_LONG_OPTIONS of the long-named option actually found. + Only valid when a long-named option was found. */ + +int option_index; + +/* Handle permutation of arguments. */ + +/* Describe the part of ARGV that contains non-options that have + been skipped. `first_nonopt' is the index in ARGV of the first of them; + `last_nonopt' is the index after the last of them. */ + +static int first_nonopt; +static int last_nonopt; + +/* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,optind), which contains all + the options processed since those non-options were skipped. + + `first_nonopt' and `last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + +#ifdef __STDC__ +static void exchange (char ** argv); + +static void exchange (char ** argv) +#else +static void +exchange (argv) + char **argv; +#endif +{ + int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *); + char **temp = (char **) alloca (nonopts_size); + + /* Interchange the two blocks of data in ARGV. */ + + bcopy (&argv[first_nonopt], temp, nonopts_size); + bcopy (&argv[last_nonopt], &argv[first_nonopt], + (optind - last_nonopt) * sizeof (char *)); + bcopy (temp, &argv[first_nonopt + optind - last_nonopt], nonopts_size); + + /* Update records for the slots the non-options now occupy. */ + + first_nonopt += (optind - last_nonopt); + last_nonopt = optind; +} + +/* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If `getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If `getopt' finds another option character, it returns that character, + updating `optind' and `nextchar' so that the next call to `getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, `getopt' returns `EOF'. + Then `optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set `opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in `optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in `optarg', otherwise `optarg' is set to zero. + + If OPTSTRING starts with `-' or `+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with `+' instead of `-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a `=', or else the in next ARGV-element. + When `getopt' finds a long-named option, it returns 0 if that option's + `flag' field is nonzero, the value of the option's `val' field + otherwise. */ + +int +getopt (argc, argv, optstring) + int argc; + char **argv; + CONST char *optstring; +{ + optarg = 0; + + /* Initialize the internal data when the first call is made. + Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + + if (optind == 0) + { + first_nonopt = last_nonopt = optind = 1; + + nextchar = 0; + + /* Determine how to handle the ordering of options and nonoptions. */ + + if (optstring[0] == '-') + { + ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + ordering = REQUIRE_ORDER; + ++optstring; + } + else +#ifndef MSDOS + if (getenv ("_POSIX_OPTION_ORDER") != 0) + ordering = REQUIRE_ORDER; + else +# endif + ordering = PERMUTE; + } + + if (nextchar == 0 || *nextchar == 0) + { + if (ordering == PERMUTE) + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange (argv); + else if (last_nonopt != optind) + first_nonopt = optind; + + /* Now skip any additional non-options + and extend the range of non-options previously skipped. */ + + while (optind < argc + && (argv[optind][0] != '-' + || argv[optind][1] == 0) + && (_getopt_long_options == 0 + || argv[optind][0] != '+' + || argv[optind][1] == 0)) + optind++; + last_nonopt = optind; + } + + /* Special ARGV-element `--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if (optind != argc && !strcmp (argv[optind], "--")) + { + optind++; + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange (argv); + else if (first_nonopt == last_nonopt) + first_nonopt = optind; + last_nonopt = argc; + + optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if (optind == argc) + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (first_nonopt != last_nonopt) + optind = first_nonopt; + return EOF; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if ((argv[optind][0] != '-' || argv[optind][1] == 0) + && (_getopt_long_options == 0 + || argv[optind][0] != '+' || argv[optind][1] == 0)) + { + if (ordering == REQUIRE_ORDER) + return EOF; + optarg = argv[optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Start decoding its characters. */ + + nextchar = argv[optind] + 1; + } + + if (_getopt_long_options != 0 + && (argv[optind][0] == '+' + || (_getopt_long_only && argv[optind][0] == '-')) + ) + { + CONST struct option *p; + char *s = nextchar; + int exact = 0; + int ambig = 0; + CONST struct option *pfound = 0; + int indfound; + + while (*s && *s != '=') + s++; + + /* Test all options for either exact match or abbreviated matches. */ + for (p = _getopt_long_options, option_index = 0; p->name; + p++, option_index++) + if (!strncmp (p->name, nextchar, s - nextchar)) + { + if (s - nextchar == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == 0) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second nonexact match found. */ + ambig = 1; + } + + if (ambig && !exact) + { + fprintf (stderr, "%s: option `%s' is ambiguous\n", + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + return '?'; + } + + if (pfound != 0) + { + option_index = indfound; + optind++; + if (*s) + { + if (pfound->has_arg > 0) + optarg = s + 1; + else + { + fprintf (stderr, + "%s: option `%c%s' doesn't allow an argument\n", + argv[0], argv[optind - 1][0], pfound->name); + nextchar += strlen (nextchar); + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + fprintf (stderr, "%s: option `%s' requires an argument\n", + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + return '?'; + } + } + nextchar += strlen (nextchar); + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + /* Can't find it as a long option. If this is getopt_long_only, + and the option starts with '-' and is a valid short + option, then interpret it as a short option. Otherwise it's + an error. */ + if (_getopt_long_only == 0 || argv[optind][0] == '+' || + index (optstring, *nextchar) == 0) + { + if (opterr != 0) + fprintf (stderr, "%s: unrecognized option `%c%s'\n", + argv[0], argv[optind][0], nextchar); + nextchar += strlen (nextchar); + optind++; + return '?'; + } + } + + /* Look at and handle the next option-character. */ + + { + char c = *nextchar++; + char *temp = index (optstring, c); + + /* Increment `optind' when we start to process its last character. */ + if (*nextchar == 0) + optind++; + + if (temp == 0 || c == ':') + { + if (opterr != 0) + { + if (c < 040 || c >= 0177) + fprintf (stderr, "%s: unrecognized option, character code 0%o\n", + argv[0], c); + else + fprintf (stderr, "%s: unrecognized option `-%c'\n", + argv[0], c); + } + return '?'; + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*nextchar != 0) + { + optarg = nextchar; + optind++; + } + else + optarg = 0; + nextchar = 0; + } + else + { + /* This is an option that requires an argument. */ + if (*nextchar != 0) + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr != 0) + fprintf (stderr, "%s: option `-%c' requires an argument\n", + argv[0], c); + c = '?'; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + nextchar = 0; + } + } + return c; + } +} + +#ifdef TEST + +/* Compile with -DTEST to make an executable for use in testing + the above definition of `getopt'. */ + +int +main (argc, argv) + int argc; + char **argv; +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + + c = getopt (argc, argv, "abc:d:0123456789"); + if (c == EOF) + break; + + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ diff --git a/fonts/utilities/ps2mf/getopt.h b/fonts/utilities/ps2mf/getopt.h new file mode 100644 index 0000000000..151379fc69 --- /dev/null +++ b/fonts/utilities/ps2mf/getopt.h @@ -0,0 +1,102 @@ +/* declarations for getopt + Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +extern char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns EOF, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +extern int optind; + +/* Callers store zero here to inhibit the error message `getopt' prints + for unrecognized options. */ + +extern int opterr; + +/* Describe the long-named options requested by the application. + _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an + element containing a name which is zero. + + The field `has_arg' is: + 0 if the option does not take an argument, + 1 if the option requires an argument, + 2 if the option takes an optional argument. + + If the field `flag' is nonzero, it points to a variable that is set + to the value given in the field `val' when the option is found, but + left unchanged if the option is not found. + + To have a long-named option do something other than set an `int' to + a compiled-in constant, such as set a value from `optarg', set the + option's `flag' field to zero and its `val' field to a nonzero + value (the equivalent single-letter option character, if there is + one). For long options that have a zero `flag' field, `getopt' + returns the contents of the `val' field. */ + +struct option +{ + char *name; + int has_arg; + int *flag; + int val; +}; + +#ifdef __STDC__ +extern const struct option *_getopt_long_options; +#else +extern struct option *_getopt_long_options; +#endif + +/* If nonzero, '-' can introduce long-named options. + Set by getopt_long_only. */ + +extern int _getopt_long_only; + +/* The index in GETOPT_LONG_OPTIONS of the long-named option found. + Only valid when a long-named option has been found by the most + recent call to `getopt'. */ + +extern int option_index; + +#ifdef __STDC__ +int getopt (int argc, char **argv, const char *shortopts); +int getopt_long (int argc, char **argv, const char *shortopts, + const struct option *longopts, int *longind); +int getopt_long_only (int argc, char **argv, const char *shortopts, + const struct option *longopts, int *longind); +void envopt(int *pargc, char ***pargv, char *optstr); +#else +int getopt (); +int getopt_long (); +int getopt_long_only (); +void envopt(); +#endif diff --git a/fonts/utilities/ps2mf/hints.mf b/fonts/utilities/ps2mf/hints.mf new file mode 100644 index 0000000000..9a836e6af4 --- /dev/null +++ b/fonts/utilities/ps2mf/hints.mf @@ -0,0 +1,619 @@ +% hints.mf --- an attempt at PostScript Type-1 Hints in METAFONT for use +% with PS2MF. +% +% Copyright (c) 1992 I. Lee Hetherington, all rights reserved. I have +% not yet decided on what copyright restrictions I will place here. +% Probably something like TeX's copyright. I think the GNU copyleft +% is far too extreme. +% +% The general scheme for hint implementation is apply vertical (hstem) +% and horizontal (vstem) hints separately. For each direction, we +% first collect the stems in a sorted list. At this point we reject +% overlapping or duplicate stems. When we first need to use the +% hints, we make sure that piecewise linear transformations are +% computed. These METAFONT transformations depend on the stem or +% inter-stem region a particular x- or y-coordinate falls in. These +% transformations are easily computed once the stems specified in +% character space are placed in pixel space. This stem placement is +% more complicated in the vertical direction because of the BlueValues +% font-level hints. +% +% Currently the implemented hints are BlueValues, OtherBlues, +% BlueScale, BlueShift, BlueFuzz, hstem, hstem3, vstem, vstem3, `Hint +% Replacement', and `Flex'. The hints FamilyBlues, FamilyOtherBlues +% are not implemented as we only apply hints at the font and character +% level, not across an entire font family. The hints StdHW, StdVW, +% StemSnapH, and StemSnapV are not implemented. It would probably not +% be very difficult to add these. The ForceBold, LanguageGroup, +% RndStemUp, and ExpansionFactor are also not implemented. +% +% Hint replacement ignores previous stem hints unless the same stem +% was used previously. In this case, the stem is placed the same as +% it was before. If after replacement a single stem is respecified +% without the other original stems, we can place it as it was placed +% before. However, *both* edges of the stem must be identical. This +% may now be irrelevant since stems are placed independently now +% (except in the case of hstem3 and vstem3, of course). +% +% I make no claim to that these hints have exactly the same effect as +% Adobe PostScript font rasterizer. The hints and their interactions +% can be quite complicated. The hint implementation in this file is +% based solely on my interpretation of their effects given their +% description in the book "Adobe Type 1 Font Format, Version 1.1". +% +% There is certainly room for improvement: both with respect to hint +% effects and implementation efficiency. Running METAFONT can take +% quite a while. I've made some attempt at caching placement results +% using METAFONT vector to reduce redundant computation. One +% improvement I can think of is replacing the stem gathering and +% sorting (h_insert and v_insert) with C code in PS2MF. Another is +% predetermining which stems are effected by the blue values. Most of +% the other placement/transformation opertions need to be done in +% METAFONT because these operations are dependent on device resolution +% and magnification. +% +% I welcome comments, suggestions, fixes, and improvements. I plan on +% commenting this code more when I get a chance. The comments are +% pretty sparse at the moment. +% +% If you want to disable the hint mechanism, specify `hinting:=0' +% before this file is included. METAFONT will run much faster but +% will produce inconsistent stem widths at low resolutions. At higher +% resolutions these hints are much less important. +% +% 1.0 beta 3/30/92 I. Lee Hetherington (ilh@lcs.mit.edu) + +if unknown hinting: hinting := 1; fi + +% expansion and slanting (same as `xscaled expansion slanted slanting') +if unknown expansion: expansion := 1; fi +if unknown slanting: slanting := 0; fi + +% make sure character space units are defined +if unknown FX#: FX# := 0.001pt#; fi +if unknown FY#: FY# := 0.001pt#; fi +FX# := FX# * expansion; % incorporate expansion here so hints know about it +u# := FX#; +v# := FY#; +define_pixels(u,v,FX,FY); + +boolean debug; debug := false; + +% like round but rounds to the nearest half +def roundhalf(expr x) = (round(x+0.5)-0.5) enddef; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% horizontal (vstem) hints + +extra_beginchar := extra_beginchar & "h_init;numeric h[][]sc;"; + +% initialize structures +def h_init = + numeric h.r,h[]s,h[]p,h[]pc; + boolean h.triple; + transform h[]t; + h.r := 1; + h.triple := false; +enddef; + +% insert new stem into sorted list +% requires that stems don't overlap +% toss duplicates +def h_insert(expr a, b) = + boolean flag; flag:=false; % temporary flag to exit loop + if h.r = 1: % no stems thus far + h[1]s := a; + h[2]s := b; + h.r := 3; + elseif a > h[h.r-1]s: % at end + h[h.r]s := a; + h[h.r+1]s := b; + h.r := h.r + 2; + else: % we need to search for location and shift elements + for i = 1 step 2 until h.r-2: + exitif ((h[i]s >= a) and (h[i]s <= b)) or + ((h[i+1]s >= a) and (h[i+1]s <= b)); + if a < h[i]s: + % insert here, so shift remaining elements up by two + for j = h.r-1 downto i: + h[j+2]s := h[j]s; + endfor + h[i]s := a; + h[i+1]s := b; + h.r := h.r + 2; + flag := true; + fi + exitif flag; + endfor + fi +enddef; + +% horizontal stem width (for vstem's) +def hsw(expr a,b) = max(1, round(abs(a-b)*u)) enddef; + +% place stems in pixel space +def h_place = + if h.triple: + h2p - h1p = vsw(h1s, h2s) - 1; + h4p - h3p = vsw(h3s, h4s) - 1; + h6p - h5p = vsw(h5s, h6s) - 1; + if unknown h[h1s][h2s]sc: % cached? + h3p - h2p = h5p - h4p; + h1p = roundhalf(h1p - (0.5[h1p,h2p] - 0.5[h1s,h2s]*u)); + h3p = roundhalf(h3p - (0.5[h3p,h4p] - 0.5[h3s,h4s]*u)); + h[h1s][h2s]sc := h1p; + h[h3s][h4s]sc := h3p; + h[h5s][h6s]sc := h5p; + else: + h1p = h[h1s][h2s]sc; + h3p = h[h3s][h4s]sc; + h5p = h[h5s][h6s]sc; + fi + elseif h.r > 1: + for i = 1 step 2 until h.r-2: + h[i+1]p - h[i]p = hsw(h[i]s,h[i+1]s) - 1; + if unknown h[h[i]s][h[i+1]s]sc: % cached? + h[i]p = roundhalf(h[i]p - (0.5[h[i]p,h[i+1]p] - 0.5[h[i]s,h[i+1]s]*u)); + h[h[i]s][h[i+1]s]sc := h[i]p; + else: + h[i]p = h[h[i]s][h[i+1]s]sc; + fi + endfor + fi + if debug: + for i = 1 upto h.r-1: + message "h" & decimal(i) & ": " & decimal(h[i]s) & + " (" & decimal(h[i]p) & ")"; + endfor + fi +enddef; + +% build separate transformations for each region +def h_transforms = + if unknown h1p: h_place; fi + if h.r = 1: h[0]t := identity xscaled u; + else: + % first region (not stem) + h[0]t := identity shifted (-h[1]s,0) + xscaled u + shifted (h[1]p,0); + % last region (not stem) + h[h.r-1]t := identity shifted (-h[h.r-1]s,0) + xscaled u + shifted (h[h.r-1]p,0); + % other regions + for i = 1 upto h.r - 2: + h[i]t := identity shifted (-h[i]s,0) + xscaled + (if h[i+1]p = h[i]p: 0 + else: ((h[i+1]p - h[i]p) / (h[i+1]s - h[i]s)) fi) + shifted (h[i]p,0); + endfor + fi + if debug: + for i = 0 upto h.r-1: + show xxpart h[i]t; + endfor + fi +enddef; + +% find region according to x-coordinate +def h_region(expr x) = + if h.r = 1: 0 + elseif x < h[1]s: 0 + elseif x >= h[h.r-1]s: (h.r - 1) + else: + for i = 2 upto h.r-1: + if x < h[i]s: (i - 1) fi + exitif (x < h[i]s); + endfor + fi +enddef; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% vertical (hstem) hints with support for BlueValues, OtherBlueValues, +% BlueScale, BlueShift, and BlueFuzz + +extra_beginchar := extra_beginchar & "v_init;numeric v[][]sc;"; + +% initialize structures +def v_init = + numeric v.r,v[]s,v[]p,v[]pc; + boolean v.triple; + transform v[]t; + v.r := 1; + v.triple := false; +enddef; + +% insert new stem into sorted list +% requires that stems don't overlap +def v_insert(expr a, b) = + boolean flag; flag:=false; % temporary flag to exit loop + if v.r = 1: % no stems thus far + v[1]s := a; + v[2]s := b; + v.r := 3; + elseif a > v[v.r-1]s: % at end + v[v.r]s := a; + v[v.r+1]s := b; + v.r := v.r + 2; + else: % we need to search for location and shift elements + for i = 1 step 2 until v.r-2: + exitif ((v[i]s >= a) and (v[i]s <= b)) or + ((v[i+1]s >= a) and (v[i+1]s <= b)); + if a < v[i]s: + % insert here, so shift remaining elements up by two + for j = v.r-1 downto i: + v[j+2]s := v[j]s; + endfor + v[i]s := a; + v[i+1]s := b; + v.r := v.r + 2; + flag := true; + fi + exitif flag; + endfor + fi +enddef; + +% Blue stuff +boolean suppress; % suppress overshoot +suppress := v < blue_scale; + +def find_bot_blue(expr y) = + numeric blue.pos, blue.over; + for i = 1 upto bot_blues.n: + exitif known blue.pos; + if (y >= bot_blues[i]o - blue_fuzz) and (y <= bot_blues[i]p): + blue.pos := bot_blues[i]p; + blue.over := bot_blues[i]o; + fi + endfor +enddef; + +def find_top_blue(expr y) = + numeric blue.pos, blue.over; + for i = 1 upto top_blues.n: + exitif known blue.pos; + if (y >= top_blues[i]p) and (y <= top_blues[i]o + blue_fuzz): + blue.pos := top_blues[i]p; + blue.over := top_blues[i]o; + fi + endfor +enddef; + +% vertical stem width (for hstem's) +def vsw(expr a,b) = max(1, round(abs(a-b)*v)) enddef; + +% place stems in pixel space paying attention to blue stuff +% (currently ignore v.triple) +% CHECK CACHING IN HERE. MIGHT NOT NEED TO DO BLUE STUFF SO OFTEN +def v_place = + if v.triple: % ignore blue stuff for hstem3 + v2p - v1p = vsw(v1s, v2s) - 1; + v4p - v3p = vsw(v3s, v4s) - 1; + v6p - v5p = vsw(v5s, v6s) - 1; + if unknown v[v1s][v2s]sc: % cached? + v3p - v2p = v5p - v4p; + v1p = roundhalf(v1p - (0.5[v1p,v2p] - 0.5[v1s,v2s]*v)); + v3p = roundhalf(v3p - (0.5[v3p,v4p] - 0.5[v3s,v4s]*v)); + v[v1s][v2s]sc := v1p; + v[v3s][v4s]sc := v3p; + v[v5s][v6s]sc := v5p; + else: + v1p = v[v1s][v2s]sc; + v3p = v[v3s][v4s]sc; + v5p = v[v5s][v6s]sc; + fi + elseif v.r > 1: + for i = 1 step 2 until v.r-2: + find_bot_blue(v[i]s); + if known blue.pos: + % position according to blue values + if suppress: + v[i]p = roundhalf(blue.pos * v); + else: + v[i]p = roundhalf(blue.pos * v) - + max(if v[i]s <= blue.pos-blue_shift: 1 else: 0 fi, + round((blue.pos - if v[i]s < blue.over: blue.over + else: v[i]s fi)*v)); + fi + v[i+1]p = v[i]p + vsw(v[i]s,v[i+1]s) - 1; + fi + find_top_blue(v[i+1]s); + if known blue.pos: + % position according to blue values + if suppress: + v[i+1]p := roundhalf(blue.pos * v); + else: + v[i+1]p := roundhalf(blue.pos * v) + + max(if v[i+1]s >= blue.pos+blue_shift: 1 else: 0 fi, + round((if v[i+1]s > blue.over: blue.over + else: v[i+1]s fi - blue.pos)*v)); + fi + % Note that it is possible for the top of a stem to be fall in a + % top zone and the bottom to fall in a bottom zone. Therefore, only + % set v[i]p (bottom) if it wasn't set previously. + if unknown v[i]p: v[i]p := v[i+1]p - (vsw(v[i]s,v[i+1]s) - 1); fi + fi + endfor + % place remaining stems if not under blue control + for i = 1 step 2 until v.r-2: + if unknown v[i]p: + v[i+1]p = v[i]p + vsw(v[i]s,v[i+1]s) - 1; + if unknown v[v[i]s][v[i+1]s]sc: % cached? + v[i]p = roundhalf(v[i]p - (0.5[v[i]p,v[i+1]p] - 0.5[v[i]s,v[i+1]s]*v)); + v[v[i]s][v[i+1]s]sc := v[i]p; + else: + v[i]p = v[v[i]s][v[i+1]s]sc; + fi + fi + endfor + fi + if debug: + for i = 1 upto v.r-1: + message "v" & decimal(i) & ": " & decimal(v[i]s) & + " (" & decimal(v[i]p) & ")"; + endfor + fi +enddef; + +% build separate transformations for each region +def v_transforms = + if unknown v1p: v_place; fi + if v.r = 1: v[0]t := identity yscaled v; + else: + % first region (not stem) + v[0]t := identity shifted (0,-v[1]s) + yscaled v + shifted (0,v[1]p); + % last region (not stem) + v[v.r-1]t := identity shifted (0,-v[v.r-1]s) + yscaled v + shifted (0,v[v.r-1]p); + % other regions + for i = 1 upto v.r - 2: + v[i]t := identity shifted (0,-v[i]s) + yscaled + (if v[i+1]p = v[i]p: 0 + else: ((v[i+1]p - v[i]p) / (v[i+1]s - v[i]s)) fi) + shifted (0,v[i]p); + endfor + fi + if debug: + for i = 0 upto v.r-1: + show yypart v[i]t; + endfor + fi +enddef; + +% find region according to y-coordinate +def v_region(expr y) = + if v.r = 1: 0 + elseif y < v[1]s: 0 + elseif y >= v[v.r-1]s: (v.r - 1) + else: + for i = 2 upto v.r-1: + if y < v[i]s: + (i - 1) + fi + exitif (y < v[i]s); + endfor + fi +enddef; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% actual pair (point) and path transformations + +% transform a pair (point) to pixel space, caching x and y coordinates +% separately for future use +def hv_pixel(expr p) = + if unknown h[xpart p]pc: + hide(h[xpart p]pc := xpart(p transformed h[h_region(xpart p)]t)) + fi + if unknown v[ypart p]pc: + hide(v[ypart p]pc := ypart(p transformed v[v_region(ypart p)]t)) + fi + (h[xpart p]pc, v[ypart p]pc) +enddef; + +% do the region-dependent tranformation on a point or path +def hv_transform(expr p) = + if unknown v0t: hide(v_transforms) fi + if unknown h0t: hide(h_transforms) fi + if pair p: hv_pixel(p) + else: % path + for i = 0 upto length p - 1: + hv_pixel(point i of p) .. controls + hv_pixel(postcontrol i of p) and hv_pixel(precontrol i+1 of p) .. + endfor + hv_pixel(point (length p) of p) + fi +enddef; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% proofing stuff -- display stem hints on proof sheets + +% Mark a vstem specified in character space. Note that the hints aren't known +% at this time so they can't be applied to the stem. +def mark_vstem(expr a,b) = + one := h + 20; + two := -d - 20; + aa := round(a*u); + bb := round(b*u); + proofrule((aa,two),(aa,one)); proofrule((bb,two),(bb,one)); + if proofing>3: + screenrule((aa,two),(aa,one)); screenrule((bb,two),(bb,one)); fi +enddef; + +% Mark a hstem specified in character space. Note that the hints aren't known +% at this time so they can't be applied to the stem. +def mark_hstem(expr a,b) = + one := -20; + two := w + 20; + aa := round(a*v); + bb := round(b*v); + proofrule((one,aa),(two,aa)); proofrule((one,bb),(two,bb)); + if proofing>3: + screenrule((one,aa),(two,aa)); screenrule((one,bb),(two,bb)); fi +enddef; + +% Mark blue value ranges. +def mark_blues = + for i = 1 upto top_blues.n: + one := -30; + two := w + 30; + aa := round(top_blues[i]o*v); + bb := round(top_blues[i]p*v); + proofrule((one,aa),(two,aa)); proofrule((one-10,bb),(two+10,bb)); + if proofing>3: + screenrule((one,aa),(two,aa)); screenrule((one,bb),(two,bb)); fi + endfor + for i = 1 upto bot_blues.n: + one := -30; + two := w + 30; + aa := round(bot_blues[i]o*v); + bb := round(bot_blues[i]p*v); + proofrule((one,aa),(two,aa)); proofrule((one-10,bb),(two+10,bb)); + if proofing>3: + screenrule((one,aa),(two,aa)); screenrule((one,bb),(two,bb)); fi + endfor +enddef; +extra_beginchar := extra_beginchar & "mark_blues;"; + + +numeric subpath_label; subpath_label := ASCII "a"; +extra_beginchar := extra_beginchar & + "subpath_label:=ASCII " & ditto & "a" & ditto & ";"; + +% Mark path points. If p is a pair (point) then it is a control point. +% Control points are only plotted if proofing > 2, but they are left +% unlabelled. +def mark_points(expr p) = + if path p: + for i = 0 upto length p: + makelabel(char(subpath_label) & decimal(i), point i of p); + endfor + if proofing > 2: % plot control points too + for i = 1 upto length p - 1: + makelabel("", postcontrol i of p); + makelabel("", precontrol i of p); + endfor + makelabel("", postcontrol 0 of p); + makelabel("", precontrol (length p - 1) of p); + fi + subpath_label:=subpath_label+1; + elseif (pair p) and (proofing>2): makelabel("", p) + fi +enddef; + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% macros used in character descriptions + +% store hint commands in this string for future incorporation +string delayed_hints; delayed_hints:=""; + +% specify delayed hints +def dh(expr s) = + if hinting>0: hide(delayed_hints := delayed_hints & s & ";") fi +enddef; + +% incorporate delayed hints +def ih = + if hinting>0: hide(h_init; v_init; scantokens delayed_hints; + delayed_hints:="") fi +enddef; + +% vertical stem hint +def vs(expr a,b) = + if hinting>0: hide(h_insert(a,b); if proofing>0: mark_vstem(a,b); fi) fi +enddef; + +% vstem3 indicator +def vst = if hinting>0: hide(h.triple:=true) fi enddef; + +% horizontal stem hint +def hs(expr a,b) = + if hinting>0: hide(v_insert(a,b); if proofing>0: mark_hstem(a,b); fi) fi +enddef; + +% hstem3 indicator +def hst = if hinting>0: hide(v.triple:=true) fi enddef; + +% apply hints +def ah(expr p) = + hide(if proofing>0: + if hinting>0: mark_points(hv_transform(p)); + else: mark_points(p xscaled u yscaled v); fi + fi) + if hinting>0: hv_transform(p) + else: (p xscaled u yscaled v) fi +enddef; + +% line to +def lt(expr a,b) = + -- (a,b) +enddef; + +% line to (after hint replacement) +def lth(expr a,b) = + -- ih ah((a,b) +enddef; + +% curve to +def ct(expr a,b,c,d,e,f) = + .. controls (a,b) and (c,d) .. (e,f) +enddef; + +% curve to (after hint replacement) +def cth(expr a,b,c,d,e,f) = + .. controls ah((a,b)) and ih ah((c,d)) .. ah((e,f) +enddef; + +% flex +def fl(expr rx,ry,ax,ay,bx,by,cx,cy,dx,dy,ex,ey,fx,fy,height) = + if (abs((rx,ry) - (cx,cy))*u >= 0.01*height): % use curves + ct(ax,ay,bx,by,cx,cy) + ct(dx,dy,ex,ey,fx,fy) + else: + lt(fx,fy) % replace curves with line + fi +enddef; + +% flex (after hint replacement) +def flh(expr rx,ry,ax,ay,bx,by,cx,cy,dx,dy,ex,ey,fx,fy,height) = + if (abs((rx,ry) - (cx,cy))*u >= 0.01*height): % use curves + cth(ax,ay,bx,by,cx,cy) + ct(dx,dy,ex,ey,fx,fy) + else: + lth(fx,fy) % replace curves with line + fi +enddef; + +% close path +def cp = -- cycle enddef; + +% Draw by filling and stroking the path (helps greatly with small sizes). +% We specify slanting here but not expansion because that's already been +% incorporated. +def dr expr c = + addto currentpicture contour (c slanted slanting) withpen pencircle; +enddef; + +picture chp[]; + +% seac (standard encoding accented character) use previously created +% pictures. When specifying accent shift, use slanting to correctly +% position accent. +def seac(expr achar,bchar,adx,ady) = + currentpicture := chp[bchar] + + chp[achar] shifted ((adx*u, ady*v) slanted slanting); +enddef; + +% non-zero winding rule for filling instead of default positive rule +def nonzerowinding = cull currentpicture dropping (0,0); enddef; +extra_endchar := extra_endchar & "nonzerowinding;"; + +turningcheck := 0; % no checking because directions are known + +autorounding := smoothing := 0; % we're doing hints ourselves diff --git a/fonts/utilities/ps2mf/myerror.c b/fonts/utilities/ps2mf/myerror.c new file mode 100644 index 0000000000..c6855658b0 --- /dev/null +++ b/fonts/utilities/ps2mf/myerror.c @@ -0,0 +1,20 @@ +/* myerror.c */ + +#include <stdio.h> +#ifndef AIX +# include <stdlib.h> +#endif +#include "defines.h" +#include "myerror.h" + +#ifdef __STDC__ +void error (char * s) +#else +void error (s) +char * s; +#endif +{ + fprintf (stderr, "\n%s\n", s); + if (* s == '!') exit (UNSUCCESSFUL); +} + diff --git a/fonts/utilities/ps2mf/myerror.h b/fonts/utilities/ps2mf/myerror.h new file mode 100644 index 0000000000..2defddde52 --- /dev/null +++ b/fonts/utilities/ps2mf/myerror.h @@ -0,0 +1,3 @@ +/* myerror.h */ + +void error __P((char * s)); diff --git a/fonts/utilities/ps2mf/mymalloc.c b/fonts/utilities/ps2mf/mymalloc.c new file mode 100644 index 0000000000..3281a3b6bf --- /dev/null +++ b/fonts/utilities/ps2mf/mymalloc.c @@ -0,0 +1,24 @@ +/* mymalloc.c */ + +#include <stdio.h> +#ifndef AIX +# include <stdlib.h> +#endif +#include "defines.h" +#include "myerror.h" +#include "mymalloc.h" + +#ifdef __STDC__ +char * my_malloc (unsigned int len) +#else +char * my_malloc (unsigned len) +int len; +#endif +{ + char * p; + + p = (char *) malloc (len); + if (p == NULL) error ("! out of memory"); + return (p); +} + diff --git a/fonts/utilities/ps2mf/mymalloc.h b/fonts/utilities/ps2mf/mymalloc.h new file mode 100644 index 0000000000..9450dfc562 --- /dev/null +++ b/fonts/utilities/ps2mf/mymalloc.h @@ -0,0 +1,3 @@ +/* mymalloc.h */ + +char * my_malloc __P((unsigned int len)); diff --git a/fonts/utilities/ps2mf/myopen.c b/fonts/utilities/ps2mf/myopen.c new file mode 100644 index 0000000000..32d6f7378b --- /dev/null +++ b/fonts/utilities/ps2mf/myopen.c @@ -0,0 +1,42 @@ +/* myopen.c */ + +#include <stdio.h> +#ifndef AIX +# include <stdlib.h> +#endif +#include <string.h> +#include "defines.h" +#include "myopen.h" +#include "mymalloc.h" +#include "myerror.h" + +#ifdef __STDC__ +FILE * my_open (char * file_name, char * extension , char * mode) +#else +FILE * my_open (file_name, extension, mode) +char * file_name, * extension, * mode; +#endif +{ + char * tmp_file_name; + int i, lastext; + FILE * out_file; + + tmp_file_name = (char *) my_malloc (sizeof (char) + * (strlen (file_name) + 5)); + strcpy (tmp_file_name, file_name); + lastext = -1; + for (i = 0; tmp_file_name [i]; i ++) + if (tmp_file_name [i] == '.') lastext = i; + else + if (tmp_file_name [i] == '/') lastext = -1; + if (lastext == -1) strcat (tmp_file_name, extension); + if ((out_file = fopen (tmp_file_name, mode)) == NULL) + { + fprintf (stderr, "Cannot open %s for %s\n", tmp_file_name, + mode [0] == 'r' ? "reading" : "writing"); + exit (UNSUCCESSFUL); + } + free (tmp_file_name); + return (out_file); +} + diff --git a/fonts/utilities/ps2mf/myopen.h b/fonts/utilities/ps2mf/myopen.h new file mode 100644 index 0000000000..94ae6703b9 --- /dev/null +++ b/fonts/utilities/ps2mf/myopen.h @@ -0,0 +1,3 @@ +/* myopen.h */ + +FILE * my_open __P((char * file_name, char * extension , char * mode)); diff --git a/fonts/utilities/ps2mf/pfa2chr.c b/fonts/utilities/ps2mf/pfa2chr.c new file mode 100644 index 0000000000..53a5acf745 --- /dev/null +++ b/fonts/utilities/ps2mf/pfa2chr.c @@ -0,0 +1,107 @@ +/* HEX2CHR.C */ + +#define VERSION "1.0 (beta)" + +#include <stdio.h> +#include <string.h> +#ifndef AIX +#include <stdlib.h> +#endif +#include "defines.h" +#include "myopen.h" +#include "pfa2chr.h" + +void give_usage () +{ + fprintf (stderr, "Usage: pfa2chr [<somepfa>[.pfa]|-]"); + fprintf (stderr, " [<somechr>[.chr]|-]\n"); + exit (UNSUCCESSFUL); +} + +#ifdef __STDC__ +void preamble (int argc, char ** argv) +#else +void preamble (argc, argv) +int argc; +char ** argv; +#endif +{ + if (argc == 1) give_usage (); + if (strequ (argv [1], "-")) pfa_file = stdin; + else pfa_file = my_open (argv [1], ".pfa", "r"); + if (argc == 3) + { + if (strequ (argv [2], "-")) chr_file = stdout; + else chr_file = my_open (argv [2], ".chr", "wb"); + } + else chr_file = my_open (argv [1], ".chr", "wb"); +} + +void postamble () +{ + fclose (pfa_file); + fclose (chr_file); + exit (SUCCESSFUL); +} + +#ifdef __STDC__ +unsigned char DeCrypt (unsigned char ch1, unsigned char ch2) +#else +unsigned char DeCrypt (ch1, ch2) +unsigned char ch1, ch2; +#endif +{ + unsigned char plain, cipher; + + if ('A' <= ch1 && ch1 <= 'F') ch1 -= 'A' - 10; + else if ('a' <= ch1 && ch1 <= 'f') ch1 -= 'a' - 10; + else ch1 -= '0'; + if ('A' <= ch2 && ch2 <= 'F') ch2 -= 'A' - 10; + else if ('a' <= ch2 && ch2 <= 'f') ch2 -= 'a' - 10; + else ch2 -= '0'; + cipher = ch1 * 16 + ch2; + plain = (cipher ^ (er >> 8)); + er = (cipher + er) * ec1 + ec2; + return plain; +} + +#ifdef __STDC__ +void main (int argc, char ** argv) +#else +void main (argc, argv) +int argc; +char ** argv; +#endif +{ + int i, o, in_size; + int skip_salt = TRUE; + char * efp; + + fprintf (stderr, "This is pfa2chr, version: %s\n", VERSION); + preamble (argc, argv); + while (fgets (in_buff, MAX_BUFFER, pfa_file) != NULL) + { + if (strequ (in_buff, "currentfile eexec\n")) break; + fprintf (chr_file, "%s", in_buff); + } + for (;;) + { + if (fgets (in_buff, MAX_BUFFER + 1, pfa_file) == NULL) break; + in_size = strlen (in_buff) - 1; + if (in_buff [in_size - 1] == '\n') in_size --; + for (i = o = 0; i < in_size; i += 2) + out_buff [o ++] = DeCrypt (in_buff [i], + in_buff [i + 1]); + out_buff [o] = '\0'; + if ((efp = strstr (out_buff, "closefile\n")) != NULL) + o = (efp - out_buff) + 10; + if (skip_salt) + { + fwrite (out_buff + EEXEC_SKIP_BYTES, + o - EEXEC_SKIP_BYTES, 1, chr_file); + skip_salt = FALSE; + } + else fwrite (out_buff, o, 1, chr_file); + } + postamble (); +} diff --git a/fonts/utilities/ps2mf/pfa2chr.h b/fonts/utilities/ps2mf/pfa2chr.h new file mode 100644 index 0000000000..0edaadb801 --- /dev/null +++ b/fonts/utilities/ps2mf/pfa2chr.h @@ -0,0 +1,13 @@ +/* pfa2chr.h */ + +#define EEXEC_SKIP_BYTES 4 +#define MAX_BUFFER 512 + +unsigned short int er = 55665; +unsigned short int ec1 = 52845; +unsigned short int ec2 = 22719; + +FILE * pfa_file, * chr_file; +char in_buff [MAX_BUFFER + 1], out_buff [MAX_BUFFER]; + +unsigned char DeCrypt __P((unsigned char ch1, unsigned char ch2)); diff --git a/fonts/utilities/ps2mf/pfb2mf.tex b/fonts/utilities/ps2mf/pfb2mf.tex new file mode 100644 index 0000000000..5000979163 --- /dev/null +++ b/fonts/utilities/ps2mf/pfb2mf.tex @@ -0,0 +1,383 @@ +% Gerard, je zult waarschijnlijk de header een beetje moeten editen. +% Maar dit is mijn verhaal uit de Proceedings van Praag (met verbeterde +% typefouten) + +\documentstyle[euro92]{article} + +\font\times=times +\font\manfnt=manfnt +\def\METAFONT{{\manfnt META}\-{\manfnt FONT}} + +\title{Incorporating PostScript fonts in \TeX{}} +\author{Erik-Jan Vens} +\titlehead{PostScript Type One to \METAFONT{}} +\authorhead{E.J. Vens} +\affiliation{Rijks Universiteit Groningen\\ + ICCE\\ + P.O.Box 335\\ + 9700 AH \ Groningen\\ + the Netherlands\\ + {\tt E.J.Vens@icce.rug.nl}} + +\begin{document} + +\maketitle + +\begin{abstract} +\noindent {\tt pfb2mf} Provides the \TeX{} community with an interface to the +PostScript Type One fonts. There is an overwhelming amount of these fonts for +sale and there are a lot of fonts in the Public Domain, so it extends the +range of typefaces the \TeX{} user can choose from. +\end{abstract} + +\section{The typical look of a \TeX-ed document} + +\subsection{Some of my background} + +As a novice \TeX{}\footnote{Just as some people do mention that they denote +`he and/or she' by just using `he', my usage of `\TeX' means `\TeX{} and/or +\LaTeX'.} user, one will often be very enthousiastic about the program. At +least, from those days when I was a rookie \TeX{} user, I remember a sort of +passion for what was possible with this incredible program. It was in 1985 and +our university's computing centre had a Canon BLP-8 hooked up to their +VAX~8650. I was a student then and used to work there almost every evening, +sometimes nights. There was this typical small group of people working in the +only room which was open to general users. And typically we would gather +around the coffee-machine and discuss all sorts of things. + +One of us knew about this program called \TeX. He showed me some results and I +was so impressed that the next day I visited the library to pick up `The \TeX +book'. (Needless to say, of course it was `\TeX{} and \METAFONT: New +Directions in Typesetting', so it was of little help.) Anyways, I spent many +hours trying to create masterpieces of the publishing art. I was very +enthousiastic about the program. + +And I became even more enthousiastic when I met fellow \TeX ers, or saw +publications made with \TeX. But, how did I see these were made \TeX? It was +precisely because they were all typeset with the Computer Modern font family. + +\subsection{How and why did Knuth create the Computer Modern font family} + +When Knuth decided to write \TeX, he wanted to be able to finish his series +`The Art of Computer Programming' with digital typography. As he writes in +`The Errors of \TeX': `The genesis of \TeX{} probably took place on +1~February~1977, when~I first chanced to see the output of a high-resolution +typesetting machine. I was told that this fine typography [$\ldots$] was +produced by entirely digital methods; yet I could see no difference between +the digital type and `real' type. Therefore I realized that a central aspect +of printing had been reduced to bit manipulation. As a computer scientist, I +could not resist the challenge to improve print quality by manipulating those +bits better. [$\ldots$] By 13~February I~had changed my plan to spend a +forthcoming sabbatical year in South America; instead of travelling to an +exotic place and working on Volume~4 of {\it The Art of Computer Programming}, +I~had decided to stay at Stanford and work on digital typography.' + +He also needed a typeface. He chose Monotype Modern No.~8A, of which he says +in `Computers~\&~Typesetting, Vol.~E': `In letterpress printing, modern fonts +were technically troublesome because their delicate hairlines and serifs were +particularly susceptible to damage; the broken letters produced a degraded +text image. In digital typography with sufficient resolution, the delicate +forms of modern can be rendered precisely. Computer typesetting and +photolithographic printing are capable of reproducing modern typefaces with a +clarity and sharpness unobtainable at the time of the original development of +the style'. + +Undoubtly, this is true. Anyone who has ever seen a text set in Computer +Modern come out of a phototypesetter, knows this striking feeling of beauty. +Only, most applications of \TeX{} that I have seen, do not end up on a +2400~dpi phototypesetter. The typical outputresolution is~300~dpi for a +laserprinter, 240~dpi for a dotmatrix printer and 400~dpi for the NeXT +laserprinter. So choosing fonts that render well at low resolutions is +certainly worthwhile. + +\subsection{Why there are no serious attempts at creating other faces} + +Creating a typeface from scratch is an extremely difficult task that takes +lots of time, patience and maybe energy. The only other complete family of +typefaces designed with \METAFONT{} is Neenie Billawala's Pandora. This is not +just a recreation of an existing font, it is a series of tools, drivers and +parameters that make up a family of faces, as she has described in TUGboat, +Vol.~10, (1989), No.~4, pp.~481--489. + +I am still working on a font together with a friend, where I~do most of the +programming and he does most of the designing. But this is our long, cold +winter's sunday afternoon project, so it's not nearly finished, even though we +started out one-and-a-half-year ago. + +And there are more people who have done some work in this area. Yannis +Haralambous did some. He and other people have created new fonts, notably for +Indian languages, Greek, Hebrew and Russian. But the \TeX{} community is not a +very large one, and so the field of font creation remains a largely +undiscovered one. + +\section{The wealth of the world of PostScript fonts} + +But maybe we do not need to wait for new fonts written in \METAFONT. One of +the many attractions of the PostScript world is it's large range of available +typefaces. Even in the Public Domain one can find numerous nice looking fonts. +And if you consider buying them, there is such a large choice, that it becomes +virtually impossible to get to know them all before taking your pick. So one +tends to start at the traditional, standard PostScript look of a document. + +\subsection{The standard Times Roman plus Courier document} + +In much the same way that a \TeX ed document can be recognized by the use of +Computer Modern, can a standard PostScript document be recognized by the +combination of Times Roman and Courier, with Courier being slightly too thin +next to the Times. Most people who come from the world of computer science +know this combination from books as Kernighan~\&~Ritchie's `The C Programming +Language' and `Kernighan~\&~Pike's `The UNIX Programming Environment'. + +Other traditional PostScript fonts include AvantGarde, Bookman, Helvetica, New +Century Schoolbook, Palatino and some loose fonts as Zapf Dingbats and Zapf +Chancery. + +\subsection{But there are more fonts} + +The past few years --as fonts grew cheaper and cheaper-- many users have +gotten used to be able to buy fonts. If one looks at the Top~40 bestsellers +list of Adobe, one will notice that both in Europa and in the USA, Adobe +Garamond is in the Top~10. On the other hand, Neville Brody's Arcadia, +Industria and Insignia are the number one in the USA, where in Europe they +rank only at~27. In Europe e.g.\ the GillSans ranks very high. Even in the +`Jobs' section of a widely read Dutch newspaper one can find many, many uses +of GillSans. Even Flora and Praxis (both by Dutch designer Gerard Unger) can +be found often. + +\section{Combing the worlds of \TeX{} and PostScript fonts} + +Wouldn't it be nice if the user of \TeX{} could incorporate the use of +PostScript fonts in a \TeX{} document? \TeX{} still is one of the best, if not +{\bf the best} where the production of neatly spaced text and beautifully +typeset mathematics is concerned. We --as \TeX{} users-- shiver in awe when we +are confronted with the Swiss cheese output produced by WorstPervert, let +alone the {\tt eqn}-based formula editor it now provides. We don't even want +to think about WordStar, and we have seen instances where the output of +Ventura doesn't look extremely bad. We have heard that Word4Windows is nice. +But still, \TeX{} outranks them when pure text and mathematics is concerned. + +\subsection{Choosing a scheme} + +There are several possibilities open to the non Computer Modern user. + +\begin{enumerate} + +\item Completely switch to PostScript output. There is a Public Domain + PostScript emulator, written by L.~Peter Deutsch, in the GNU + distribution. One will also have to use a {\tt dvi} to {\tt ps} + translator, e.g.\ Tom Rokicki's {\tt dvips}. + +\item Use Piet Tutelaer's {\tt ps2pk} package, based on the X-Windows, + Release~5 distribution, which can translate a PostScript Type One font + to \TeX's {\tt pk} format. This is extremely useful for those users who + want fast, production quality fonts. + +\item Use my {\tt pfb2mf} package, which can translate a PostScript Type One + font to \METAFONT{} format. To create a bitmap, one will still have to + run \METAFONT. This last part of the job can be frustratingly slow, but + it does provide the \TeX{} user with options to change the output. + +\end{enumerate} + +\noindent Beware. A caveat should be here. Producing beautifully typeset +documents is just combining spaces and faces. But remember that this is an +art, rather than a job which can be automated. + +\section{What does a \METAFONT{} file look like} + +A \METAFONT{} file consists of a combination of commands to set up the +communication with \TeX, commands to set up plottable functions and commands +to set up a plot. + +\subsection{The macro-biotic aspects of \METAFONT{}} + +Just as with \TeX, macro's play an important role. And just as with \TeX, +macro's are essentialy build up from other macro's and primitives. Only +because with \TeX{} one has to make a distinction between pure text and +macro's, the macro's have to be escaped with a backslash. \METAFONT{} macro's +on the other hand do not need the escape. And \METAFONT{} macro's can even +handle binary operators. An example on p.~178 of `The \METAFONT book' states: + +${\bf primarydef } w {\rm\ dotprod } z = {}$ + +\quad $({\rm xpart } w \ast{} {\rm xpart } z + {\rm ypart } w \ast{} {\rm +ypart } z) {\bf\ enddef}$. + +\noindent I will not discuss this in in-depth, but basically this defines an +infix operator `{\tt dotprod}' which takes a left and a right operand, it then +returns a value. + +There a couple of important macro's and primitives: + +\begin{itemize} + +\item `{\tt beginchar}' sets up the beginning of the definition of a glyph. It + takes four parameters: + + \begin{enumerate} + + \item the character number, this can be given as a decimal, octal or + hexadecimal number, or as the representation of the character, + e.g.~{\tt"a"}. + \item the width of the surrounding box. The character's shape can stick + out of it's box, but this box provides the metrics with which + \TeX{} will do it's calculations. + \item the height of the surrounding box. This is the height the + characters extends above the baseline. + \item the depth of the surrounding box. + \end{enumerate} + +\item `{\tt endchar}' declares the end of the definition. + +\item One can assign values to constants and variables. $u := 3.5$, or + $width\# := 3.5pt\#$, where the $\#$ denotes a sharped, i.e.\ reallife, + or not-rounded-to-the-raster value. + +\item One can declare points in space, or just their x- and y-values: $x_3 = + x_2 - x_1$, or $z_1 = ({1\over 2}width, .8h - 3.5pt)$. + +\item The points can be connected with several types of lines. E.g.\ a + straight line: $z_1 {\tt--} z_2 {\tt--} z_3$, or a smooth curve: $z_1 + {\tt..} z_2 {\tt..} z_3$. + +\item One can draw these lines with a pen, or one can fill the area that is + defined by a shape. Or combining these two. One can also erase a line, + or an area. {\tt draw} $z_1 {\tt--} z_2$ draws a straight line from + $z_1$ to $z_2$ with the current pen. {\tt fill} $z_1 {\tt..} z_2 {\tt--} + z_3 {\tt..} cycle$ fills an area defined by a smooth line from $z_1$ to + $z_2$, from there with a straight line to $z_3$, and from there with a + smooth line back to the beginning. + +\end{itemize} + +\section{What does a Type One font look like} + +We will have to do some work before we can take a look at Type One fonts with +a plain text editor. + +\subsection{From {\tt pfb} via {\tt pfa} to {\tt ps}} + +Type One fonts typically come in two flavors: binary or ascii representation. +The binary representation is just an encoded form of the ascii representation. +So, one needs a program to translate from the first to the last form. In the +{\tt pfb2mf} package that would be {\tt pfb2pfa}. The ascii version, however, +is a readable hexadecimal version of an encrypted series of PostScript +commands. Once this encryption was secret, but it is now given to the world. +So, one can translate the ascii version to human-readable PostScript. In the +{\tt pfb2mf} package this would be done with {\tt pfa2ps}. + +\subsection{What does it mean} + +All Type One fonts are outline fonts which are filled. The PostScript language +uses a reverse polish notation for it's commands, so `{\tt dx dy rlineto}' +means `draw a straight line from the currentpoint to the point which lies at a +distance $(dx, dy)$. There are very few commands: + +\begin{itemize} + +\item `{\tt endchar}' finishes a charstring outline definition. + +\item `{\tt seac}' makes an accented character from two other characters in + the font program. + +\item `{\tt closepath}' closes a subpath. (Surprise!) + +\item All sorts of drawing and moving commands. These are all relative to the + currentpoint. Some commands are abbreviations for others, one can say, + e.g.\ {\tt dx hmoveto}, which means {\tt dx 0 rmoveto}. All lines are + straight lines. The curves are B\'ezier cubics, so {\tt dx1 dy1 dx2 dy2 + dx3 dy3 rrcurveto} means `construct a curve from $currentpoint$ to + $currentpoint + (dx1 + dx2 + dx3, dy1 + dy2 + dy3)$, using $currentpoint + + (dx1, dy1)$ and $currentpoint + (dx1 + dx2, dy1 + dy2)$ as + controlpoints. + +\item Then there are the stem commands. This is the most difficult to + understand part of a Type One font. I am still not sure whether I really + do. Anyways, stem commands define zones within which the renderer can + choose a position so that the output will look good. It is strongly + related to \METAFONT's commands for `Discreteness and Discretion'. + +\item We can define subroutines and call them from within the Type One font + program. So, any translation program must learn these subroutines and + apply them when called. + +\item `{\tt setcurrentpoint}' sets the currentpoint, for how else can we start + a curve where each point is defined in terms of it's predecessor? + +\end{itemize} + +\section{The uninteresting bits and pieces} + +The definition of how this is all done is not very interesting, so I will give +just one example and leave it to the reader to pick up the sources if this +reader is interested in more details. + +\subsection{An example of the font} + +There is a freely distributable version of Times New Roman out on the net in +TrueType format. I have translated this to Type One format. This is an example +of what the fonts looks like: + +\bigskip + +{\times Times New Roman} + +\subsection{An example of the letter A in sourceform} + +\begin{verbatim} +/A {7 722 hsbw 450 221 rmoveto -256 hlineto -45 -104 rlineto + -12 -26 -5 -20 0 -12 rrcurveto 0 -10 5 -9 10 -8 + rrcurveto 9 -7 21 -5 32 -2 rrcurveto -18 vlineto -209 + hlineto 18 vlineto 28 4 18 7 8 8 rrcurveto 16 15 19 32 + 20 48 rrcurveto 233 545 rlineto 17 hlineto 231 -551 + rlineto 18 -44 17 -29 15 -13 rrcurveto 15 -13 21 -8 27 + -1 rrcurveto -18 vlineto -261 hlineto 18 vlineto 27 1 17 + 4 10 8 rrcurveto 9 7 5 9 0 11 rrcurveto 0 14 -7 23 -13 + 31 rrcurveto -40 95 rlineto -14 36 rmoveto -112 268 + rlineto -115 -268 rlineto 227 hlineto endchar } ND +\end{verbatim} + +\begin{verbatim} +beginchar(65,722*FX#,677*FY#,0*FY#); "A"; +fill ((457,221) -- (201,221) -- (156,117) .. controls + (144,91) and (139,71) .. (139,59) .. controls (139,49) + and (144,40) .. (154,32) .. controls (163,25) and + (184,20) .. (216,18) -- (216,0) -- (7,0) -- (7,18) .. + controls (35,22) and (53,29) .. (61,37) .. controls + (77,52) and (96,84) .. (116,132) -- (349,677) -- + (366,677) -- (597,126) .. controls (615,82) and + (632,53) .. (647,40) .. controls (662,27) and + (683,19) .. (710,18) -- (710,0) -- (449,0) -- (449,18) + .. controls (476,19) and (493,23) .. (503,31) .. + controls (512,38) and (517,47) .. (517,58) .. controls + (517,72) and (510,95) .. (497,126) -- (457,221) -- + cycle) xscaled FX# yscaled FY#; +unfill ((443,257) -- (331,525) -- (216,257) -- (443,257) -- + cycle) xscaled FX# yscaled FY#; +endchar; +\end{verbatim} + +\section{Does it meet realworld constraints?} + +No, as of yet, it doesn't. However, the process of hinting is time-consuming +and therefor very, very slow. So, if it is fast production quality you are +after, you are well advised to pick up Piet Tutelaer's {\tt ps2pk}. + +I want to extend the possibilities of the program to provide the user with +ways of implementing meta-ness. So if you'd like to fiddle with the font's +parameters, {\tt pfb2mf} is what you want. It will provide a great deal of +tuneable parameters, and you can lift out part of a font an use that as a +basis for other things. + +\section{And where can I get all this?} + +Both {\tt pfb2mf} and {\tt ps2pk} are ftp-able. E.g.\ from my home machine +{\tt obelix.icce.rug.nl}. It can be found in {\tt pub/erikjan}. + +\section{A warning} + +Be careful! If you plan on using more fonts, you will not only have to worry +about you text, and the layout you choose, you will also have to worry about +what font you are going to use. + +\end{document} diff --git a/fonts/utilities/ps2mf/pfb2pfa.c b/fonts/utilities/ps2mf/pfb2pfa.c new file mode 100644 index 0000000000..9d0b5992bc --- /dev/null +++ b/fonts/utilities/ps2mf/pfb2pfa.c @@ -0,0 +1,152 @@ +/* pfb2pfa.c === modified version of: */ +/* pfb2ps.c - Copyright 1991-05-12 Erik Wallin, d87-ewa@nada.kth.se. + This program may be distributed freely, modified or included in + other free programs long as this copyright notice is still + included. +*/ + +#define VERSION "1.0 (beta)" + +#include <stdio.h> +#ifndef AIX +# include <stdlib.h> +#endif +#include <string.h> +#include "defines.h" +#include "myopen.h" +#include "mymalloc.h" +#include "pfb2pfa.h" + +#define getb() (getc (pfb_file)) +#define getlen() (getb () | getb () << 8 | getb () << 16 | getb () << 24) + +void give_usage () +{ + fprintf (stderr, "Usage: pfb2pfa <somepfb>[.pfb]"); + fprintf (stderr, " [<somepfa>[.pfa]|-]\n"); + exit (UNSUCCESSFUL); +} + +#ifdef __STDC__ +void preamble (int argc, char ** argv) +#else +void preamble (argc, argv) +int argc; +char ** argv; +#endif +{ + if (argc == 1) give_usage (); + pfb_file = my_open (argv [1], ".pfb", "rb"); + if (argc == 3) + { + if (strequ (argv [2], "-")) pfa_file = stdout; + else pfa_file = my_open (argv [2], ".pfa", "w"); + } + else pfa_file = my_open (argv [1], ".pfa", "w"); +} + +void postamble () +{ + fclose (pfb_file); + fclose (pfa_file); + exit (SUCCESSFUL); +} + +#ifdef __STDC__ +void main (int argc, char ** argv) +# else +void main (argc, argv) +int argc; +char ** argv; +# endif +{ + int t; + unsigned int l, i; + unsigned char * buf; + + fprintf (stderr, "This is pfb2pfa, version %s\n", VERSION); + preamble (argc, argv); + while (! feof (pfb_file)) + { + if (getb () != 128) + { + fprintf (stderr, "Magic number (128) not found "); + fprintf (stderr, "or no input on input.\n"); + exit (UNSUCCESSFUL); + } + t = getb (); + fprintf (stderr, "Type: %d, ", t); + switch (t) + { + case 1: + { + l = (unsigned int) getlen (); + fprintf (stderr, " plain text, length %ld\n", + (long) l); + buf = (unsigned char *) my_malloc (l); + if (fread (buf, sizeof (unsigned char), + l, pfb_file) != l) + { + fprintf (stderr, "Wrong length of "); + fprintf (stderr, "ascii field: %ld ", + (long) l); + fprintf (stderr, "or could not read "); + fprintf (stderr, "file.\n"); + exit (UNSUCCESSFUL); + } +# ifdef unix + for (i = 0; i < l; i ++) + if (buf [i] == (unsigned char) '\r') + buf [i] = (unsigned char) '\n'; +# endif + if (fwrite (buf, sizeof (unsigned char), + l, pfa_file) != l) + { + fprintf (stderr, "Could not write "); + fprintf (stderr, "output.\n"); + exit (UNSUCCESSFUL); + } + free (buf); + } + break; + case 2: + { + l = (unsigned int) getlen (); + fprintf (stderr, " binary data, length %ld\n", + (long) l); + buf = (unsigned char *) my_malloc (l); + if (fread (buf, sizeof (unsigned char), + l, pfb_file) != l) + { + fprintf (stderr, "Wrong length of "); + fprintf (stderr, "binary field: %ld ", + (long) l); + fprintf (stderr, "or could not read "); + fprintf (stderr, "file.\n"); + exit (UNSUCCESSFUL); + } + for (i = 0; i < l ; i ++) + { + fprintf (pfa_file, "%2.2X", buf [i]); + if (! ((i + 1) % HEX_PER_LINE)) + fprintf (pfa_file, "\n"); + } + fprintf (pfa_file, "\n"); + free (buf); + } + break; + case 3: + { + fprintf (stderr, "End of file\n"); + postamble (); + } + break; + default: + { + fprintf (stderr, "Unknown field type: %d\n", t); + exit (UNSUCCESSFUL); + } + } + } + postamble (); +} diff --git a/fonts/utilities/ps2mf/pfb2pfa.h b/fonts/utilities/ps2mf/pfb2pfa.h new file mode 100644 index 0000000000..987e24e443 --- /dev/null +++ b/fonts/utilities/ps2mf/pfb2pfa.h @@ -0,0 +1,5 @@ +/* pfb2pfa.h */ + +#define HEX_PER_LINE 32 + +FILE * pfb_file, * pfa_file; diff --git a/fonts/utilities/ps2mf/ps2mf.c b/fonts/utilities/ps2mf/ps2mf.c new file mode 100644 index 0000000000..1f9a4a40b4 --- /dev/null +++ b/fonts/utilities/ps2mf/ps2mf.c @@ -0,0 +1,145 @@ +/* ps2mf.c */ + +#define VERSION "1.1 (beta)" + +#include <stdio.h> +#ifndef AIX +#include <stdlib.h> +#endif +#include <string.h> +#include "defines.h" +#include "myopen.h" +#include "ps2mf.h" +#include "ps2mfutl.h" +#include "getopt.h" +#ifdef MSDOS +#include <float.h> +#endif + +AFM_info_tp * AFM_chars; +configuration_info_tp * TeX_configuration; +ignore_info_tp * ignore_list; +char font_name [255], coding_scheme[255]; +float italic_angle; +bool fixed_pitch; +int x_height, font_space, font_quad; +bool x_height_is_defined; +char buffer [255], obuffer [255]; +char * param; + + +void give_usage () +{ + fprintf (stderr, "Usage: ps2mf <basename>\n"); + fprintf (stderr, " [-p <someps>[.ps]][-a <someafm>[.afm]]\n"); + fprintf (stderr, " [-m <somemf>[.mf]][-c <someconf>[.cfg]]\n"); + exit (UNSUCCESSFUL); +} + +FILE * ps_file, * afm_file, * mf_file, * conf_file; + +#ifdef __STDC__ +void preamble (int argc, char ** argv) +#else +void preamble (argc, argv) +int argc; +char ** argv; +#endif +{ + int c, i, lastext; + bool ps_file_defined, afm_file_defined, mf_file_defined, + conf_file_defined; + char * ps_file_name, * afm_file_name, * mf_file_name, * conf_file_name, + * base_file_name; + + ps_file_defined = FALSE; + afm_file_defined = FALSE; + mf_file_defined = FALSE; + conf_file_defined = FALSE; + + while ((c = getopt (argc, argv, "p:m:a:c:")) != EOF) + { + switch (c) + { + case 'p': + { + ps_file_name = optarg; + ps_file_defined = TRUE; + } + break; + case 'm': + { + mf_file_name = optarg; + mf_file_defined = TRUE; + } + break; + case 'a': + { + afm_file_name = optarg; + afm_file_defined = TRUE; + } + break; + case 'c': + { + conf_file_name = optarg; + conf_file_defined = TRUE; + } + break; + case '?': + { + give_usage (); + } + break; + } + } + if (! argv [optind]) give_usage (); + base_file_name = (char *) my_malloc (sizeof (char) + * strlen (argv [optind]) + 5); + strcpy (base_file_name, argv [optind]); + lastext = -1; + for (i = 0; base_file_name [i]; i ++) + { + if (base_file_name [i] == '.') lastext = i; + else + { + if (base_file_name [i] == '/') lastext = -1; + } + } + if (lastext != -1) base_file_name [lastext] = '\0'; + ps_file = my_open (ps_file_defined ? ps_file_name : base_file_name, + ".ps", "r"); + afm_file = my_open (afm_file_defined ? afm_file_name : base_file_name, + ".afm", "r"); + mf_file = my_open (mf_file_defined ? mf_file_name : base_file_name, + ".mf", "w"); + conf_file = my_open (conf_file_defined ? conf_file_name : base_file_name, + ".cfg", "r"); +} + +void postamble () +{ + fclose (ps_file); + fclose (afm_file); + fclose (mf_file); + fclose (conf_file); +} + +#ifdef __STDC__ +void main (int argc, char ** argv) +#else +void main (argc, argv) +int argc; +char ** argv; +#endif +{ + fprintf (stderr, "This is ps2mf, version %s.\n", VERSION); + preamble (argc, argv); + fprintf (stderr, " Starting to read configuration-file\n"); + parse_config (); + fprintf (stderr, " Starting to read fontmetric-file\n"); + parse_AFM (); + fprintf (stderr, " Starting to read postscript-file\n"); + parse_PS (); + postamble (); + exit (SUCCESSFUL); +} diff --git a/fonts/utilities/ps2mf/ps2mf.h b/fonts/utilities/ps2mf/ps2mf.h new file mode 100644 index 0000000000..820a9dde24 --- /dev/null +++ b/fonts/utilities/ps2mf/ps2mf.h @@ -0,0 +1,75 @@ +/* ps2mf.h */ + +typedef struct AFM_info +{ + struct AFM_info * next; + int AFM_num, TeX_num, width; + char * AFM_name; + int bbox_llx, bbox_lly, bbox_urx, bbox_ury; + struct lig * ligs; + struct kern * kerns; + struct pcc * pccs; + bool in_MF_file; +} AFM_info_tp; +extern struct AFM_info * AFM_chars; + +typedef struct configuration_info +{ + struct configuration_info * next; + int TeX_num; + char * AFM_name; + struct lig * ligs; +} configuration_info_tp; +extern struct configuration_info * TeX_configuration; + +typedef struct ignore_info +{ + struct ignore_info * next; + char * AFM_name; +} ignore_info_tp; +extern struct ignore_info * ignore_list; + +typedef struct lig +{ + struct lig * next; + char * succ, * sub; +} lig_tp; + +typedef struct kern +{ + struct kern * next; + char * succ; + int delta; +} kern_tp; + +typedef struct pcc +{ + struct pcc * next; + char * part_name; + int x_offset, y_offset; +} pcc_tp; + +extern FILE * ps_file, * afm_file, * mf_file, * conf_file; +extern char font_name [255], coding_scheme [255]; +extern float italic_angle; +extern bool fixed_pitch; +extern int x_height, font_space, font_quad; +extern bool x_height_is_defined; +extern float x_scale, y_scale; + +int find_TeX_num __P((char * p)); +FILE * my_open __P((char * name, char * extension, char * mode)); +void parse_AFM __P((void)); +void parse_PS __P((void)); +void parse_config __P((void)); +void process_ligatures_and_kerns __P((void)); +void postamble __P((void)); +void preamble __P((int argc, char ** argv)); +void test_AFM_info __P((void)); + +#ifdef HAVE_NO_STRSTR +char * strstr __P((char * s, char * find)); +# endif +#ifdef HAVE_NO_ALLOCA +char * alloca __P((unsigned size)); +# endif diff --git a/fonts/utilities/ps2mf/ps2mfutl.c b/fonts/utilities/ps2mf/ps2mfutl.c new file mode 100644 index 0000000000..ae8579bd1b --- /dev/null +++ b/fonts/utilities/ps2mf/ps2mfutl.c @@ -0,0 +1,217 @@ +/* ps2mfutl.c */ + +#include <stdio.h> +#ifndef AIX +#include <stdlib.h> +#endif +#include <string.h> +#include "defines.h" +#include "mymalloc.h" +#include "ps2mf.h" +#include "ps2mfutl.h" +#ifdef MSDOS +#include <float.h> +#endif + + +#ifdef __STDC__ +void error (char * s) +#else +void error (s) +char * s; +#endif +{ + fprintf (stderr, "\n%s\n", s); + if (obuffer [0]) + { + fprintf (stderr, "%s\n", obuffer); + while (param > buffer) + { + fprintf (stderr, " "); + param --; + } + fprintf (stderr, "^n\n"); + } + if (* s == '!') exit (UNSUCCESSFUL); +} + +#ifdef __STDC__ +int transform (int x, int y) +#else +int transform (x, y) +int x, y; +#endif +{ + double acc; + + acc = 1.0 * x + 0.0 * y; + /* ^=efactor ^=slant */ + return ((int) (acc >= 0.0 ? acc + 0.5 : acc - 0.5)); +} + +#ifdef __STDC +int get_line (FILE * in_file) +#else +int get_line (in_file) +FILE * in_file; +#endif +{ + char * p; + int c; + + param = buffer; + do c = getc (in_file); + while (c == ' ' || c == '\r' || c == '\n'); + ungetc (c, in_file); + for (p = buffer; (c = getc (in_file)) != EOF && c != '\n' + && c != '\r'; /* skip */) * p ++ = c; + if (buffer [0] == '%') return (get_line (in_file)); + * p = 0; + strcpy (obuffer, buffer); + if (p == buffer && c == EOF) return (0); + return (1); +} + +#ifdef __STDC +void un_get_line (FILE * in_file) +#else +void un_get_line (in_file) +FILE * in_file; +#endif +{ + char * p; + int c; + + for (p = obuffer; * p; p ++) /* skip */; + for (* p = '\n'; p >= obuffer; p --) + { + if (! ungetc (* p, in_file) == * p) + error ("! could not unget"); + } +} + +#ifdef __STDC__ +int get_token (FILE * in_file) +#else +int get_token (in_file) +FILE * in_file; +#endif +{ + if (! * param) if (! get_line (in_file)) return (0); + return (1); +} + +/* Routines for input parsing: param_new_string, param_string, param_num, + param_float, expect */ + +#ifdef __STDC__ +bool is_in_delimiters (char c) +# else +bool is_in_delimiters (c) +char c; +# endif +{ + if (c == '{' || c == '[' || c == '(' + || c == ')' || c == ']' || c == '}') return (TRUE); + return (FALSE); +} + +char * param_new_string () +{ + char * p, * q; + + p = param; + if (is_in_delimiters (* p)) p ++; + else while (* p > ' ' && ! is_in_delimiters (* p)) p ++; + q = my_malloc ((int) (p - param + 1)); + if (* p != 0) * p ++ = 0; + strcpy (q, param); + while (* p && * p <= ' ') p ++; + param = p; + return (q); +} + +char * param_string () +{ + char * p, * q; + + p = param; + if (is_in_delimiters (* p)) p ++; + else while (* p > ' ' && ! is_in_delimiters (* p)) p ++; + q = param; + if (* p != 0) * p ++ = 0; + while (* p && * p <= ' ') p ++; + param = p; + return (q); +} + +int param_oct () +{ + char * p; + int i; + + p = param_string (); + if (sscanf (p, "%o", & i) != 1) error ("! octal number expected"); + return (i); +} + +int param_hex () +{ + char * p; + int i; + + p = param_string (); + if (sscanf (p, "%x", & i) != 1) error ("! hexadecimal number expected"); + return (i); +} + +int param_num () +{ + char * p; + int i; + + p = param_string (); + if (sscanf (p, "%d", & i) != 1) error ("! integer expected"); + return (i); +} + +float param_float () +{ + char * p; + float f; + + p = param_string (); + if (sscanf (p, "%f", & f) != 1) error ("! number expected"); + return (f); +} + +#ifdef __STDC__ +void expect (char * s) +#else +void expect (s) +char * s; +#endif +{ + if (! strequ (param_string (), s)) + { + fprintf (stderr, "%s expected.", s); + error ("! syntax error"); + } +} + +#ifdef __STDC__ +AFM_info_tp * find_AFM_info_for (char * p) +#else +AFM_info_tp * find_AFM_info_for (p) +char * p; +#endif +{ + AFM_info_tp * ai; + + for (ai = AFM_chars; ai; ai = ai -> next) + { + if (strequ (p, ai -> AFM_name)) return (ai); + } + return (NULL); +} + diff --git a/fonts/utilities/ps2mf/ps2mfutl.h b/fonts/utilities/ps2mf/ps2mfutl.h new file mode 100644 index 0000000000..d9f63500c4 --- /dev/null +++ b/fonts/utilities/ps2mf/ps2mfutl.h @@ -0,0 +1,20 @@ +/* ps2mfutl.h */ + +extern char buffer [255], obuffer [255]; /* buffer is modified while parsing, + /* obuffer is an unmodified copy of the input */ +extern char * param; /* current position in "buffer" */ + +void error __P((char * s)); +void expect __P((char * s)); +AFM_info_tp * find_AFM_info_for __P((char * p)); +int get_line __P((FILE * in_file)); +int get_token __P((FILE * in_file)); +bool is_in_delimiters __P((char c)); +float param_float __P((void)); +int param_hex __P((void)); +char * param_new_string __P((void)); +int param_num __P((void)); +int param_oct __P((void)); +char * param_string __P((void)); +int transform __P((int x, int y)); +void un_get_line __P((FILE * in_file)); diff --git a/fonts/utilities/ps2mf/strstr.c b/fonts/utilities/ps2mf/strstr.c new file mode 100644 index 0000000000..08d60911e3 --- /dev/null +++ b/fonts/utilities/ps2mf/strstr.c @@ -0,0 +1,75 @@ +/*- + * Copyright (c) 1990 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#if defined(LIBC_SCCS) && !defined(lint) +static char sccsid[] = "@(#)strstr.c 5.2 (Berkeley) 1/26/91"; +#endif /* LIBC_SCCS and not lint */ + +/* +#include <sys/cdefs.h> + */ +#include <stdio.h> +#include <string.h> + +/* + * Find the first occurrence of find in s. + */ +#ifdef __STDC__ +char * strstr (char * s, char * find) +# else +char * strstr (s, find) +char * s, * find; +# endif +{ + char c, sc; + int len; + + if ((c = * find ++) != 0) + { + len = strlen (find); + do + { + do + { + if ((sc = * s ++) == 0) return (NULL); + } + while (sc != c); + } + while (strncmp (s, find, len) != 0); + s --; + } + return ((char *) s); +} diff --git a/fonts/utilities/ps2mf/times.mf b/fonts/utilities/ps2mf/times.mf new file mode 100644 index 0000000000..d5d89297ea --- /dev/null +++ b/fonts/utilities/ps2mf/times.mf @@ -0,0 +1,8657 @@ +% TimesNewRoman +mode_setup; +if unknown FontSize: FontSize := 10pt#; fi +FX# := FontSize * 0.0010; +FY# := FontSize * 0.0010; +bot_blues.n := 1; +bot_blues1o := -15; +bot_blues1p := 0; +top_blues.n := 2; +top_blues1o := 460; +top_blues1p := 447; +top_blues2o := 677; +top_blues2p := 662; +blue_scale := 0.039625; +blue_shift := 7; +blue_fuzz := 1; + +input hints; + +beginchar(33,333*FX#,677*FY#,13*FY#); +"exclam"; +dr +ah((175,175) +lt(157,175) +lt(114,570) +ct(112,587,111,600,111,609) +ct(111,629,116,646,127,658) +ct(138,671,151,677,166,677) +ct(182,677,195,671,205,658) +ct(216,646,221,627,221,603) +ct(221,595,220,584,219,570) +lt(175,175) + )cp +dr +ah((166,94) +ct(180,94,193,88,204,78) +ct(214,67,220,55,220,40) +ct(220,25,214,12,204,2) +ct(193,-8,180,-13,166,-13) +ct(151,-13,138,-8,127,2) +ct(117,12,111,25,111,40) +ct(111,55,117,67,127,78) +ct(138,88,151,94,166,94) + )cp +endchar; + +beginchar(134,408*FX#,677*FY#,0*FY#); +"quotedbl"; +dr +ah((281,392) +lt(254,534) +lt(244,593) +ct(243,601,243,609,243,618) +ct(243,638,247,653,256,663) +ct(265,672,277,677,292,677) +ct(306,677,318,672,327,663) +ct(337,653,341,640,341,625) +ct(341,597,338,567,332,535) +lt(304,392) +lt(281,392) + )cp +dr +ah((102,392) +lt(75,536) +ct(67,576,64,603,64,617) +ct(64,638,69,653,77,663) +ct(86,672,98,677,112,677) +ct(127,677,138,672,148,662) +ct(157,653,162,640,162,624) +ct(162,611,157,582,149,536) +lt(123,392) +lt(102,392) + )cp +endchar; + +beginchar(35,500*FX#,677*FY#,13*FY#); +"numbersign"; +dr +ah((56,-13) +lt(101,208) +lt(18,208) +lt(18,248) +lt(109,248) +lt(143,416) +lt(18,416) +lt(18,455) +lt(152,455) +lt(196,677) +lt(237,677) +lt(192,455) +lt(357,455) +lt(404,677) +lt(445,677) +lt(398,455) +lt(481,455) +lt(481,416) +lt(391,416) +lt(357,248) +lt(481,248) +lt(481,208) +lt(349,208) +lt(303,-13) +lt(264,-13) +lt(308,208) +lt(143,208) +lt(96,-13) +lt(56,-13) + )cp +dr +ah((150,248) +lt(315,248) +lt(351,416) +lt(184,416) +lt(150,248) + )cp +endchar; + +beginchar(36,500*FX#,717*FY#,76*FY#); +"dollar"; +dr +ah((52,163) +lt(74,163) +ct(77,118,91,84,116,60) +ct(140,36,177,22,225,18) +lt(225,303) +ct(151,348,103,388,79,423) +ct(61,447,53,477,53,513) +ct(53,553,68,588,97,618) +ct(127,648,170,666,225,672) +lt(225,717) +lt(256,717) +lt(256,672) +ct(282,670,305,667,324,663) +ct(333,661,364,649,417,629) +lt(417,483) +lt(398,483) +ct(394,535,381,573,358,597) +ct(336,621,302,635,256,640) +lt(256,392) +ct(338,334,391,292,414,265) +ct(438,238,449,204,449,164) +ct(449,119,432,79,398,45) +ct(364,11,317,-8,256,-13) +lt(256,-76) +lt(225,-76) +lt(225,-13) +ct(194,-12,166,-8,140,-3) +ct(113,2,84,11,52,24) +lt(52,163) + )cp +dr +ah((225,412) +lt(225,639) +ct(193,635,168,625,153,608) +ct(137,591,129,570,129,545) +ct(129,521,136,499,150,478) +ct(165,458,190,436,225,412) + )cp +dr +ah((256,18) +ct(280,22,299,28,312,36) +ct(331,47,345,62,356,80) +ct(366,99,372,118,372,139) +ct(372,161,365,181,352,200) +ct(339,219,307,247,256,282) +lt(256,18) + )cp +endchar; + +beginchar(37,833*FX#,677*FY#,27*FY#); +"percent"; +dr +ah((679,677) +lt(197,-27) +lt(153,-27) +lt(636,677) +lt(679,677) + )cp +dr +ah((177,677) +ct(221,677,255,659,280,622) +ct(304,586,316,544,316,497) +ct(316,440,302,396,275,365) +ct(248,334,215,319,176,319) +ct(151,319,127,326,105,340) +ct(84,354,67,375,54,403) +ct(41,431,35,462,35,497) +ct(35,531,41,562,54,591) +ct(67,620,85,641,108,656) +ct(130,670,153,677,177,677) + )cp +dr +ah((176,649) +ct(159,649,144,640,132,620) +ct(119,601,112,560,112,497) +ct(112,451,115,417,123,394) +ct(128,376,137,362,149,352) +ct(155,346,164,343,174,343) +ct(190,343,203,351,214,369) +ct(230,393,239,435,239,494) +ct(239,556,231,599,215,625) +ct(204,641,191,649,176,649) + )cp +dr +ah((657,328) +ct(680,328,703,321,726,306) +ct(749,291,767,270,779,242) +ct(792,214,798,183,798,150) +ct(798,92,784,48,756,18) +ct(729,-12,696,-27,658,-27) +ct(634,-27,611,-20,589,-5) +ct(567,9,549,30,536,57) +ct(524,84,517,115,517,150) +ct(517,184,524,215,536,244) +ct(549,272,567,293,589,307) +ct(611,321,634,328,657,328) + )cp +dr +ah((657,302) +ct(641,302,628,293,617,276) +ct(602,253,595,210,595,146) +ct(595,88,602,47,617,24) +ct(628,8,641,0,657,0) +ct(672,0,685,8,697,26) +ct(713,50,721,91,721,149) +ct(721,210,713,253,697,277) +ct(686,293,673,302,657,302) + )cp +endchar; + +beginchar(38,777*FX#,677*FY#,15*FY#); +"ampersand"; +dr +ah((510,426) +lt(715,426) +lt(715,408) +ct(687,405,666,399,652,389) +ct(639,379,618,348,589,296) +ct(560,244,528,196,492,151) +ct(521,117,547,93,570,80) +ct(593,66,616,60,639,60) +ct(661,60,680,66,696,78) +ct(711,90,722,108,729,132) +lt(747,119) +ct(735,73,716,39,689,17) +ct(662,-4,631,-15,596,-15) +ct(569,-15,542,-7,514,6) +ct(487,21,457,45,424,80) +ct(384,44,348,19,315,5) +ct(283,-8,248,-15,211,-15) +ct(158,-15,115,0,83,27) +ct(52,56,36,90,36,130) +ct(36,169,50,209,79,248) +ct(107,287,160,328,238,370) +ct(223,403,213,431,207,453) +ct(201,475,199,495,199,515) +ct(199,571,219,613,260,643) +ct(292,665,328,677,369,677) +ct(408,677,439,665,464,642) +ct(488,619,500,591,500,558) +ct(500,523,489,493,465,467) +ct(441,441,400,412,340,381) +ct(381,307,424,240,469,179) +ct(526,247,555,305,555,352) +ct(555,367,550,380,541,392) +ct(533,400,523,406,510,408) +lt(510,426) + )cp +dr +ah((323,413) +ct(364,432,394,454,414,479) +ct(434,503,444,530,444,560) +ct(444,583,437,603,422,618) +ct(408,633,390,641,368,641) +ct(340,641,318,631,304,612) +ct(289,592,282,573,282,554) +ct(282,538,285,520,291,500) +ct(296,481,307,451,323,413) + )cp +dr +ah((399,108) +ct(356,166,326,209,310,236) +ct(293,263,275,297,255,337) +ct(216,314,186,290,167,263) +ct(147,236,137,206,137,175) +ct(137,140,148,109,171,83) +ct(193,57,224,43,262,43) +ct(282,43,302,48,321,56) +ct(340,64,366,81,399,108) + )cp +endchar; + +beginchar(161,180*FX#,677*FY#,0*FY#); +"quotesingle"; +dr +ah((77,392) +lt(50,536) +ct(42,576,39,603,39,617) +ct(39,638,43,653,52,663) +ct(60,672,72,677,86,677) +ct(101,677,113,672,123,662) +ct(132,653,137,640,137,625) +ct(137,612,133,582,125,536) +lt(98,392) +lt(77,392) + )cp +endchar; + +beginchar(40,333*FX#,694*FY#,213*FY#); +"parenleft"; +dr +ah((310,-195) +lt(310,-213) +ct(260,-188,219,-159,187,-126) +ct(140,-79,104,-24,79,40) +ct(53,104,41,170,41,239) +ct(41,340,65,432,115,515) +ct(165,599,230,658,310,694) +lt(310,673) +ct(270,651,237,621,211,583) +ct(186,544,166,495,154,437) +ct(141,378,135,316,135,252) +ct(135,182,140,118,151,62) +ct(159,17,170,-18,182,-45) +ct(194,-72,210,-98,230,-124) +ct(251,-149,277,-173,310,-195) + )cp +endchar; + +beginchar(41,333*FX#,694*FY#,213*FY#); +"parenright"; +dr +ah((22,673) +lt(22,694) +ct(71,669,112,640,145,607) +ct(192,560,228,504,253,440) +ct(279,376,291,310,291,240) +ct(291,139,267,47,217,-35) +ct(167,-118,102,-178,22,-213) +lt(22,-195) +ct(62,-173,95,-142,121,-104) +ct(147,-66,166,-17,178,41) +ct(191,100,197,161,197,226) +ct(197,295,191,358,181,416) +ct(173,460,163,496,151,523) +ct(138,550,122,576,102,602) +ct(82,627,55,651,22,673) + )cp +endchar; + +beginchar(42,500*FX#,694*FY#,0*FY#); +"asterisk"; +dr +ah((241,509) +ct(239,531,235,554,227,576) +ct(215,608,210,630,210,642) +ct(210,659,214,672,222,681) +ct(230,689,240,694,252,694) +ct(262,694,271,689,278,681) +ct(286,672,290,659,290,643) +ct(290,628,285,608,277,582) +ct(268,556,263,531,261,509) +ct(279,520,295,534,309,551) +ct(331,576,348,592,358,599) +ct(369,605,380,608,391,608) +ct(402,608,411,604,418,597) +ct(426,590,429,581,429,571) +ct(429,559,424,548,413,539) +ct(402,529,375,520,333,510) +ct(307,504,286,498,270,491) +ct(286,482,307,475,332,471) +ct(371,464,397,455,409,444) +ct(422,434,428,422,428,409) +ct(428,399,424,391,417,384) +ct(409,377,401,373,391,373) +ct(381,373,371,376,359,383) +ct(347,390,331,405,311,429) +ct(297,445,281,460,261,474) +ct(261,455,265,435,272,414) +ct(284,375,290,349,290,335) +ct(290,322,286,311,278,302) +ct(270,293,262,289,253,289) +ct(241,289,230,293,220,303) +ct(213,309,210,320,210,335) +ct(210,351,214,370,221,392) +ct(229,414,233,429,235,437) +ct(237,446,239,458,241,474) +ct(221,461,204,447,190,432) +ct(166,405,149,388,137,381) +ct(128,375,119,373,110,373) +ct(99,373,90,377,82,384) +ct(74,392,70,400,70,409) +ct(70,417,74,426,80,435) +ct(87,444,97,451,110,457) +ct(119,461,139,466,170,473) +ct(190,477,210,483,229,491) +ct(211,499,190,506,166,512) +ct(126,520,101,527,92,535) +ct(77,545,70,558,70,574) +ct(70,583,74,591,81,598) +ct(89,605,97,609,107,609) +ct(118,609,129,605,141,599) +ct(153,592,168,578,186,557) +ct(204,537,222,521,241,509) + )cp +endchar; + +beginchar(43,563*FX#,595*FY#,0*FY#); +"plus"; +dr +ah((261,68) +lt(261,312) +lt(18,312) +lt(18,352) +lt(261,352) +lt(261,595) +lt(300,595) +lt(300,352) +lt(544,352) +lt(544,312) +lt(300,312) +lt(300,68) +lt(261,68) + )cp +endchar; + +beginchar(44,250*FX#,97*FY#,166*FY#); +"comma"; +dr +ah((53,-166) +lt(53,-145) +ct(87,-133,113,-116,131,-93) +ct(149,-70,159,-45,159,-19) +ct(159,-13,157,-7,154,-3) +ct(152,-1,149,0,147,0) +ct(143,0,136,-3,124,-9) +ct(118,-11,111,-13,105,-13) +ct(90,-13,77,-8,67,0) +ct(58,9,53,22,53,39) +ct(53,55,59,69,72,80) +ct(84,91,99,97,116,97) +ct(138,97,157,88,174,69) +ct(190,50,199,26,199,-4) +ct(199,-38,187,-69,164,-98) +ct(141,-127,104,-149,53,-166) + )cp +endchar; + +beginchar(45,333*FX#,261*FY#,0*FY#); +"hyphen"; +dr +ah((40,261) +lt(292,261) +lt(292,187) +lt(40,187) +lt(40,261) + )cp +endchar; + +beginchar(46,250*FX#,94*FY#,13*FY#); +"period"; +dr +ah((125,94) +ct(140,94,153,89,163,78) +ct(173,68,179,55,179,40) +ct(179,25,173,12,163,2) +ct(152,-8,139,-13,125,-13) +ct(110,-13,97,-8,86,2) +ct(76,12,70,25,70,40) +ct(70,55,76,68,86,79) +ct(97,89,110,94,125,94) + )cp +endchar; + +beginchar(47,277*FX#,694*FY#,13*FY#); +"slash"; +dr +ah((280,694) +lt(40,-13) +lt(1,-13) +lt(241,694) +lt(280,694) + )cp +endchar; + +beginchar(48,500*FX#,675*FY#,11*FY#); +"zero"; +dr +ah((36,327) +ct(36,402,47,467,70,522) +ct(93,576,123,617,161,644) +ct(190,664,220,675,251,675) +ct(302,675,348,649,388,598) +ct(438,533,464,446,464,337) +ct(464,260,453,195,431,141) +ct(409,87,380,48,346,24) +ct(312,0,278,-11,247,-11) +ct(183,-11,131,26,89,100) +ct(53,162,36,238,36,327) + )cp +dr +ah((131,314) +ct(131,223,142,149,165,91) +ct(183,43,211,19,248,19) +ct(266,19,284,26,303,42) +ct(322,58,336,84,346,122) +ct(360,178,368,256,368,358) +ct(368,434,360,497,345,547) +ct(333,585,317,611,299,627) +ct(285,637,269,643,251,643) +ct(229,643,209,633,192,613) +ct(168,586,152,544,144,486) +ct(136,428,131,371,131,314) + )cp +endchar; + +beginchar(49,500*FX#,675*FY#,0*FY#); +"one"; +dr +ah((117,597) +lt(278,675) +lt(294,675) +lt(294,116) +ct(294,79,295,56,299,47) +ct(302,38,308,31,318,26) +ct(328,21,347,18,377,18) +lt(377,0) +lt(128,0) +lt(128,18) +ct(160,18,180,21,189,26) +ct(198,30,204,37,208,45) +ct(212,53,213,76,213,116) +lt(213,474) +ct(213,522,211,552,208,566) +ct(206,577,202,584,196,589) +ct(190,594,183,597,174,597) +ct(162,597,145,592,124,582) +lt(117,597) + )cp +endchar; + +beginchar(50,500*FX#,675*FY#,0*FY#); +"two"; +dr +ah((458,127) +lt(412,0) +lt(21,0) +lt(21,18) +ct(136,122,217,208,264,274) +ct(311,341,334,402,334,457) +ct(334,499,321,533,295,560) +ct(270,587,239,601,203,601) +ct(171,601,141,591,115,572) +ct(90,553,70,525,58,488) +lt(40,488) +ct(48,548,69,595,103,627) +ct(136,659,179,675,229,675) +ct(283,675,328,658,364,624) +ct(399,589,417,548,417,501) +ct(417,467,409,434,394,401) +ct(370,348,331,292,277,233) +ct(195,145,145,91,125,73) +lt(298,73) +ct(333,73,358,75,372,77) +ct(386,80,399,85,410,93) +ct(422,101,431,112,440,127) +lt(458,127) + )cp +endchar; + +beginchar(51,500*FX#,675*FY#,11*FY#); +"three"; +dr +ah((50,536) +ct(69,580,93,615,122,639) +ct(151,663,187,675,229,675) +ct(282,675,323,658,352,624) +ct(373,598,384,570,384,541) +ct(384,493,353,443,293,392) +ct(334,376,364,353,385,323) +ct(406,294,416,259,416,219) +ct(416,161,398,112,362,70) +ct(314,16,245,-11,155,-11) +ct(111,-11,80,-6,64,4) +ct(48,15,40,27,40,40) +ct(40,49,44,58,52,65) +ct(59,72,68,76,79,76) +ct(87,76,95,74,104,72) +ct(110,70,122,64,142,54) +ct(161,44,175,38,182,36) +ct(194,32,207,30,221,30) +ct(254,30,283,43,307,69) +ct(332,95,344,125,344,160) +ct(344,186,338,211,327,235) +ct(318,253,309,267,299,277) +ct(285,290,266,302,242,312) +ct(217,323,192,328,167,328) +lt(151,328) +lt(151,343) +ct(177,346,203,355,229,371) +ct(255,386,273,404,285,426) +ct(297,447,303,471,303,497) +ct(303,530,292,557,271,578) +ct(250,599,224,609,193,609) +ct(142,609,100,582,66,528) +lt(50,536) + )cp +endchar; + +beginchar(52,500*FX#,675*FY#,0*FY#); +"four"; +dr +ah((465,244) +lt(465,174) +lt(376,174) +lt(376,0) +lt(295,0) +lt(295,174) +lt(15,174) +lt(15,237) +lt(322,675) +lt(376,675) +lt(376,244) +lt(465,244) + )cp +dr +ah((295,244) +lt(295,572) +lt(63,244) +lt(295,244) + )cp +endchar; + +beginchar(53,500*FX#,662*FY#,11*FY#); +"five"; +dr +ah((434,662) +lt(395,579) +lt(196,579) +lt(153,490) +ct(239,477,307,445,358,394) +ct(401,349,423,297,423,237) +ct(423,202,416,170,402,141) +ct(387,111,370,86,348,65) +ct(327,44,303,27,276,15) +ct(238,-2,200,-11,161,-11) +ct(121,-11,93,-4,74,8) +ct(56,22,47,36,47,53) +ct(47,62,51,70,59,77) +ct(66,84,76,87,87,87) +ct(95,87,103,86,109,83) +ct(115,81,126,74,142,63) +ct(166,46,190,38,216,38) +ct(254,38,287,52,316,81) +ct(345,110,359,145,359,187) +ct(359,227,347,264,321,299) +ct(295,333,260,360,214,379) +ct(178,393,130,402,69,404) +lt(196,662) +lt(434,662) + )cp +endchar; + +beginchar(54,500*FX#,675*FY#,11*FY#); +"six"; +dr +ah((448,675) +lt(448,657) +ct(405,653,370,644,343,632) +ct(315,619,288,599,262,573) +ct(235,546,213,517,196,485) +ct(179,452,164,414,152,369) +ct(199,401,246,417,293,417) +ct(339,417,378,399,411,363) +ct(444,326,461,279,461,222) +ct(461,166,444,116,411,71) +ct(370,16,316,-11,250,-11) +ct(205,-11,167,3,135,33) +ct(73,91,42,166,42,259) +ct(42,319,54,375,78,428) +ct(102,482,136,529,180,570) +ct(224,612,266,639,307,654) +ct(347,668,385,675,419,675) +lt(448,675) + )cp +dr +ah((144,333) +ct(138,289,135,254,135,227) +ct(135,196,141,162,153,125) +ct(164,89,181,60,204,38) +ct(220,22,241,15,265,15) +ct(293,15,318,28,341,55) +ct(363,82,374,120,374,169) +ct(374,225,363,273,341,314) +ct(319,355,287,375,247,375) +ct(234,375,221,372,207,367) +ct(193,362,172,351,144,333) + )cp +endchar; + +beginchar(55,500*FX#,662*FY#,13*FY#); +"seven"; +dr +ah((100,662) +lt(455,662) +lt(455,643) +lt(234,-13) +lt(180,-13) +lt(377,582) +lt(195,582) +ct(158,582,132,577,117,569) +ct(89,553,67,530,51,500) +lt(37,505) +lt(100,662) + )cp +endchar; + +beginchar(56,500*FX#,675*FY#,11*FY#); +"eight"; +dr +ah((191,333) +ct(139,376,105,410,90,437) +ct(75,463,67,490,67,518) +ct(67,561,84,598,117,629) +ct(150,660,194,675,250,675) +ct(303,675,346,661,378,632) +ct(411,603,427,570,427,533) +ct(427,508,418,483,401,457) +ct(383,431,347,401,291,366) +ct(348,322,386,287,405,262) +ct(429,228,442,193,442,157) +ct(442,110,424,70,389,37) +ct(353,4,307,-11,249,-11) +ct(186,-11,137,8,102,47) +ct(74,78,60,112,60,150) +ct(60,180,70,209,90,238) +ct(109,266,143,298,191,333) + )cp +dr +ah((268,385) +ct(307,420,332,448,342,468) +ct(353,489,358,512,358,538) +ct(358,572,348,599,329,618) +ct(310,637,284,647,250,647) +ct(217,647,190,637,169,618) +ct(149,599,138,576,138,551) +ct(138,534,142,517,151,500) +ct(160,483,172,467,188,452) +lt(268,385) + )cp +dr +ah((214,314) +ct(187,292,167,267,154,240) +ct(141,213,135,184,135,153) +ct(135,111,146,77,169,52) +ct(192,27,221,14,257,14) +ct(292,14,320,24,341,44) +ct(362,64,373,88,373,116) +ct(373,139,366,160,354,179) +ct(331,213,284,258,214,314) + )cp +endchar; + +beginchar(57,500*FX#,675*FY#,13*FY#); +"nine"; +dr +ah((52,-13) +lt(52,4) +ct(95,5,134,14,170,33) +ct(207,52,242,86,276,133) +ct(310,181,334,233,347,290) +ct(295,257,249,241,208,241) +ct(162,241,122,259,89,295) +ct(56,331,39,378,39,438) +ct(39,496,55,547,89,593) +ct(129,647,181,675,246,675) +ct(300,675,346,652,385,608) +ct(433,552,457,483,457,402) +ct(457,328,438,260,402,196) +ct(366,132,316,80,251,38) +ct(199,4,142,-13,80,-13) +lt(52,-13) + )cp +dr +ah((355,326) +ct(361,368,364,402,364,428) +ct(364,459,358,493,348,530) +ct(337,567,322,595,302,614) +ct(282,634,260,644,235,644) +ct(206,644,180,631,159,604) +ct(137,578,126,540,126,488) +ct(126,419,140,365,169,327) +ct(190,299,216,285,248,285) +ct(263,285,280,289,301,296) +ct(321,303,339,313,355,326) + )cp +endchar; + +beginchar(58,277*FX#,460*FY#,13*FY#); +"colon"; +dr +ah((141,460) +ct(156,460,168,455,179,445) +ct(190,434,195,421,195,406) +ct(195,391,190,378,179,368) +ct(168,357,156,352,141,352) +ct(126,352,113,357,102,368) +ct(92,378,86,391,86,406) +ct(86,421,92,434,102,445) +ct(113,455,126,460,141,460) + )cp +dr +ah((140,95) +ct(155,95,168,89,178,79) +ct(189,68,194,55,194,40) +ct(194,25,189,12,178,2) +ct(167,-8,155,-13,140,-13) +ct(125,-13,112,-8,101,2) +ct(91,12,85,25,85,40) +ct(85,55,91,68,101,79) +ct(112,89,125,95,140,95) + )cp +endchar; + +beginchar(59,277*FX#,461*FY#,166*FY#); +"semicolon"; +dr +ah((137,461) +ct(152,461,165,456,176,445) +ct(186,435,191,422,191,407) +ct(191,392,186,379,176,369) +ct(165,358,152,353,137,353) +ct(122,353,109,358,99,369) +ct(88,379,83,392,83,407) +ct(83,422,88,435,99,445) +ct(109,456,122,461,137,461) + )cp +dr +ah((69,-166) +lt(69,-145) +ct(102,-133,128,-116,147,-93) +ct(165,-70,174,-45,174,-19) +ct(174,-13,172,-7,170,-3) +ct(167,-1,165,0,163,0) +ct(159,0,152,-3,140,-9) +ct(134,-11,127,-13,121,-13) +ct(105,-13,92,-8,83,0) +ct(74,9,69,22,69,39) +ct(69,55,75,69,87,80) +ct(99,91,114,97,132,97) +ct(153,97,172,88,189,69) +ct(206,50,214,26,214,-4) +ct(214,-38,203,-69,179,-98) +ct(156,-127,119,-149,69,-166) + )cp +endchar; + +beginchar(137,563*FX#,572*FY#,0*FY#); +"less"; +dr +ah((19,344) +lt(544,572) +lt(544,529) +lt(92,333) +lt(544,135) +lt(544,91) +lt(19,320) +lt(19,344) + )cp +endchar; + +beginchar(61,563*FX#,431*FY#,0*FY#); +"equal"; +dr +ah((18,431) +lt(544,431) +lt(544,391) +lt(18,391) +lt(18,431) + )cp +dr +ah((18,271) +lt(544,271) +lt(544,231) +lt(18,231) +lt(18,271) + )cp +endchar; + +beginchar(138,563*FX#,572*FY#,0*FY#); +"greater"; +dr +ah((543,318) +lt(18,91) +lt(18,133) +lt(470,329) +lt(18,527) +lt(18,572) +lt(543,342) +lt(543,318) + )cp +endchar; + +beginchar(63,443*FX#,677*FY#,13*FY#); +"question"; +dr +ah((221,156) +lt(201,156) +ct(203,197,209,231,217,258) +ct(225,284,241,322,266,370) +ct(286,406,298,435,304,454) +ct(310,474,313,494,313,514) +ct(313,555,302,588,280,613) +ct(258,637,231,649,199,649) +ct(171,649,149,643,132,629) +ct(116,616,108,602,108,586) +ct(108,574,113,559,123,541) +ct(132,524,137,511,137,501) +ct(137,490,133,480,126,472) +ct(118,464,109,460,99,460) +ct(85,460,72,467,61,480) +ct(50,494,44,513,44,537) +ct(44,573,60,606,92,634) +ct(123,663,166,677,220,677) +ct(287,677,336,657,368,618) +ct(391,589,403,557,403,523) +ct(403,499,398,475,387,450) +ct(377,425,357,395,327,361) +ct(280,308,251,270,240,248) +ct(230,225,223,195,221,156) + )cp +dr +ah((214,95) +ct(230,95,243,90,253,79) +ct(264,69,269,56,269,41) +ct(269,26,264,13,253,2) +ct(242,-7,229,-13,214,-13) +ct(199,-13,187,-7,176,2) +ct(165,13,160,26,160,41) +ct(160,56,165,69,176,79) +ct(187,90,199,95,214,95) + )cp +endchar; + +beginchar(64,920*FX#,694*FY#,215*FY#); +"at"; +dr +ah((687,467) +lt(630,272) +ct(609,200,596,153,591,134) +ct(587,114,584,99,584,87) +ct(584,76,588,68,595,61) +ct(602,53,611,50,621,50) +ct(645,50,673,62,707,85) +ct(740,109,769,148,792,201) +ct(816,255,828,310,828,368) +ct(828,424,815,475,788,522) +ct(761,570,723,606,674,631) +ct(625,656,571,669,512,669) +ct(437,669,367,649,302,609) +ct(238,569,187,512,149,437) +ct(112,362,93,284,93,204) +ct(93,129,109,61,142,0) +ct(175,-61,222,-107,282,-138) +ct(342,-170,406,-186,475,-186) +ct(561,-186,638,-163,707,-117) +ct(776,-71,830,-4,868,83) +lt(896,83) +ct(867,-5,813,-77,736,-132) +ct(659,-188,571,-215,473,-215) +ct(395,-215,323,-197,257,-160) +ct(190,-124,139,-72,102,-5) +ct(65,62,47,136,47,216) +ct(47,302,67,382,107,457) +ct(148,531,204,589,277,631) +ct(350,673,427,694,509,694) +ct(576,694,637,680,691,652) +ct(745,624,787,584,815,530) +ct(843,476,857,420,857,359) +ct(857,300,844,241,818,182) +ct(791,124,757,81,716,55) +ct(675,28,632,15,588,15) +ct(563,15,545,20,532,32) +ct(519,44,513,60,513,82) +ct(513,100,516,123,522,153) +ct(474,95,435,57,406,40) +ct(377,23,352,14,330,14) +ct(306,14,286,24,268,45) +ct(250,66,241,93,241,128) +ct(241,175,257,228,287,287) +ct(318,345,359,393,410,430) +ct(447,456,480,470,510,470) +ct(532,470,550,465,565,453) +ct(579,442,589,425,594,403) +lt(610,457) +lt(687,467) + )cp +dr +ah((516,447) +ct(491,447,466,434,441,409) +ct(404,371,373,320,347,256) +ct(327,209,318,171,318,143) +ct(318,122,324,105,336,93) +ct(347,80,360,73,375,73) +ct(393,73,413,80,434,95) +ct(455,109,477,131,500,161) +ct(522,191,539,221,549,250) +ct(567,302,577,344,577,377) +ct(577,398,571,416,559,428) +ct(547,441,533,447,516,447) + )cp +endchar; + +beginchar(65,722*FX#,677*FY#,0*FY#); +"A"; +dr +ah((457,221) +lt(201,221) +lt(156,117) +ct(144,91,139,71,139,59) +ct(139,49,144,40,154,32) +ct(163,25,184,20,216,18) +lt(216,0) +lt(7,0) +lt(7,18) +ct(35,22,53,29,61,37) +ct(77,52,96,84,116,132) +lt(349,677) +lt(366,677) +lt(597,126) +ct(615,82,632,53,647,40) +ct(662,27,683,19,710,18) +lt(710,0) +lt(449,0) +lt(449,18) +ct(476,19,493,23,503,31) +ct(512,38,517,47,517,58) +ct(517,72,510,95,497,126) +lt(457,221) + )cp +dr +ah((443,257) +lt(331,525) +lt(216,257) +lt(443,257) + )cp +chp[65]:=currentpicture; +endchar; + +beginchar(66,666*FX#,662*FY#,0*FY#); +"B"; +dr +ah((461,337) +ct(507,327,541,312,564,291) +ct(596,261,612,224,612,181) +ct(612,148,601,116,581,86) +ct(560,56,531,34,495,20) +ct(459,6,403,0,329,0) +lt(16,0) +lt(16,18) +lt(41,18) +ct(69,18,89,26,101,44) +ct(108,55,112,79,112,117) +lt(112,544) +ct(112,585,107,611,98,622) +ct(85,636,66,644,41,644) +lt(16,644) +lt(16,662) +lt(302,662) +ct(355,662,398,658,431,650) +ct(479,638,517,617,542,588) +ct(568,558,581,524,581,485) +ct(581,452,571,422,551,396) +ct(531,370,501,350,461,337) + )cp +dr +ah((206,364) +ct(218,361,231,360,247,359) +ct(262,357,279,357,298,357) +ct(345,357,381,362,405,372) +ct(429,383,447,398,460,419) +ct(473,441,479,464,479,489) +ct(479,527,463,561,432,588) +ct(400,615,354,629,293,629) +ct(261,629,232,625,206,618) +lt(206,364) + )cp +dr +ah((206,47) +ct(243,38,280,34,317,34) +ct(376,34,421,47,452,74) +ct(483,100,499,133,499,172) +ct(499,198,492,223,478,247) +ct(464,270,441,289,409,303) +ct(378,316,339,323,292,323) +ct(272,323,255,323,240,322) +ct(226,322,214,320,206,319) +lt(206,47) + )cp +endchar; + +beginchar(67,666*FX#,677*FY#,15*FY#); +"C"; +dr +ah((602,677) +lt(617,452) +lt(602,452) +ct(581,519,553,568,515,597) +ct(478,627,433,642,380,642) +ct(336,642,297,630,261,608) +ct(226,586,198,550,177,501) +ct(157,453,147,392,147,319) +ct(147,259,157,208,176,164) +ct(195,120,224,86,262,62) +ct(301,39,345,27,395,27) +ct(437,27,475,37,508,55) +ct(541,73,577,110,617,165) +lt(632,155) +ct(599,96,560,53,516,25) +ct(471,-1,419,-15,358,-15) +ct(248,-15,163,25,103,106) +ct(58,166,36,238,36,320) +ct(36,386,50,447,80,502) +ct(110,558,150,601,202,631) +ct(254,662,311,677,373,677) +ct(420,677,467,665,514,642) +ct(528,634,537,631,543,631) +ct(552,631,560,634,566,640) +ct(574,648,580,661,584,677) +lt(602,677) + )cp +chp[67]:=currentpicture; +endchar; + +beginchar(68,722*FX#,662*FY#,0*FY#); +"D"; +dr +ah((17,0) +lt(17,18) +lt(41,18) +ct(69,18,89,26,101,44) +ct(108,55,112,79,112,117) +lt(112,544) +ct(112,585,107,611,98,622) +ct(85,636,66,644,41,644) +lt(17,644) +lt(17,662) +lt(286,662) +ct(385,662,460,650,512,628) +ct(564,605,605,568,636,516) +ct(668,463,684,403,684,334) +ct(684,242,656,165,600,103) +ct(536,34,440,0,312,0) +lt(17,0) + )cp +dr +ah((206,47) +ct(247,38,282,34,310,34) +ct(385,34,448,60,498,113) +ct(547,166,572,238,572,329) +ct(572,421,547,493,498,545) +ct(448,598,384,625,306,625) +ct(276,625,243,620,206,610) +lt(206,47) + )cp +endchar; + +beginchar(69,610*FX#,662*FY#,0*FY#); +"E"; +dr +ah((208,625) +lt(208,364) +lt(354,364) +ct(392,364,417,369,430,381) +ct(446,395,456,422,458,460) +lt(476,460) +lt(476,229) +lt(458,229) +ct(453,261,448,282,444,291) +ct(438,303,429,312,416,318) +ct(402,325,382,328,354,328) +lt(208,328) +lt(208,110) +ct(208,81,210,63,212,56) +ct(215,50,220,45,226,41) +ct(233,38,245,36,263,36) +lt(375,36) +ct(413,36,440,38,457,43) +ct(474,49,490,59,506,74) +ct(526,94,546,124,568,166) +lt(587,166) +lt(530,0) +lt(20,0) +lt(20,18) +lt(43,18) +ct(59,18,74,21,88,29) +ct(98,34,105,42,109,52) +ct(113,63,115,84,115,116) +lt(115,546) +ct(115,588,110,614,102,624) +ct(90,637,70,644,43,644) +lt(20,644) +lt(20,662) +lt(530,662) +lt(538,517) +lt(519,517) +ct(512,551,504,575,496,588) +ct(488,601,475,611,459,618) +ct(445,622,422,625,390,625) +lt(208,625) + )cp +chp[69]:=currentpicture; +endchar; + +beginchar(70,556*FX#,662*FY#,0*FY#); +"F"; +dr +ah((204,625) +lt(204,365) +lt(325,365) +ct(352,365,373,371,385,384) +ct(398,396,407,420,411,456) +lt(429,456) +lt(429,232) +lt(411,232) +ct(411,258,407,277,401,289) +ct(395,301,386,310,375,316) +ct(364,322,347,325,325,325) +lt(204,325) +lt(204,117) +ct(204,83,206,60,210,50) +ct(213,42,220,35,231,29) +ct(245,21,260,18,276,18) +lt(300,18) +lt(300,0) +lt(16,0) +lt(16,18) +lt(39,18) +ct(66,18,86,25,99,41) +ct(106,51,110,77,110,117) +lt(110,544) +ct(110,578,108,600,104,611) +ct(100,619,94,626,84,632) +ct(70,640,55,644,39,644) +lt(16,644) +lt(16,662) +lt(508,662) +lt(515,516) +lt(498,516) +ct(489,547,479,570,468,584) +ct(457,599,443,609,427,616) +ct(410,622,385,625,350,625) +lt(204,625) + )cp +endchar; + +beginchar(71,722*FX#,677*FY#,15*FY#); +"G"; +dr +ah((613,677) +lt(630,468) +lt(613,468) +ct(595,520,573,559,546,585) +ct(506,623,456,643,395,643) +ct(310,643,246,609,202,542) +ct(165,486,147,419,147,341) +ct(147,278,159,221,184,168) +ct(208,116,240,78,280,54) +ct(319,30,360,18,401,18) +ct(426,18,449,21,472,27) +ct(495,33,517,42,538,54) +lt(538,246) +ct(538,279,536,301,531,311) +ct(525,321,518,329,507,334) +ct(496,340,478,342,451,342) +lt(451,361) +lt(708,361) +lt(708,342) +lt(695,342) +ct(669,342,652,333,643,317) +ct(636,305,633,281,633,246) +lt(633,43) +ct(596,23,559,8,522,0) +ct(486,-10,445,-15,401,-15) +ct(273,-15,175,25,109,107) +ct(59,169,35,240,35,320) +ct(35,378,49,434,77,488) +ct(109,551,155,600,213,634) +ct(261,662,319,677,385,677) +ct(409,677,431,675,451,671) +ct(471,667,499,658,535,645) +ct(553,638,565,635,571,635) +ct(577,635,583,638,587,643) +ct(592,649,594,660,595,677) +lt(613,677) + )cp +endchar; + +beginchar(72,722*FX#,662*FY#,0*FY#); +"H"; +dr +ah((205,354) +lt(513,354) +lt(513,544) +ct(513,578,510,600,506,611) +ct(502,619,496,626,486,632) +ct(472,640,457,644,441,644) +lt(418,644) +lt(418,662) +lt(701,662) +lt(701,644) +lt(678,644) +ct(662,644,647,640,633,632) +ct(623,627,616,619,612,609) +ct(608,598,606,576,606,544) +lt(606,117) +ct(606,83,608,60,613,50) +ct(616,42,623,35,633,29) +ct(647,21,662,18,678,18) +lt(701,18) +lt(701,0) +lt(418,0) +lt(418,18) +lt(441,18) +ct(468,18,488,25,500,41) +ct(508,51,513,77,513,117) +lt(513,318) +lt(205,318) +lt(205,117) +ct(205,83,207,60,211,50) +ct(214,42,221,35,232,29) +ct(246,21,260,18,276,18) +lt(300,18) +lt(300,0) +lt(17,0) +lt(17,18) +lt(40,18) +ct(67,18,87,25,100,41) +ct(107,51,111,77,111,117) +lt(111,544) +ct(111,578,109,600,105,611) +ct(101,619,95,626,85,632) +ct(70,640,55,644,40,644) +lt(17,644) +lt(17,662) +lt(300,662) +lt(300,644) +lt(276,644) +ct(260,644,246,640,232,632) +ct(222,627,215,619,211,609) +ct(207,598,205,576,205,544) +lt(205,354) + )cp +endchar; + +beginchar(73,333*FX#,662*FY#,0*FY#); +"I"; +dr +ah((308,18) +lt(308,0) +lt(24,0) +lt(24,18) +lt(48,18) +ct(75,18,95,25,107,41) +ct(115,51,119,77,119,117) +lt(119,544) +ct(119,578,117,600,113,611) +ct(109,619,103,626,93,632) +ct(78,640,63,644,48,644) +lt(24,644) +lt(24,662) +lt(308,662) +lt(308,644) +lt(284,644) +ct(257,644,237,636,225,620) +ct(217,609,213,584,213,544) +lt(213,117) +ct(213,83,215,60,219,50) +ct(222,42,229,35,240,29) +ct(254,21,268,18,284,18) +lt(308,18) + )cp +chp[73]:=currentpicture; +endchar; + +beginchar(74,389*FX#,662*FY#,15*FY#); +"J"; +dr +ah((99,644) +lt(99,662) +lt(383,662) +lt(383,644) +lt(359,644) +ct(331,644,312,636,300,620) +ct(292,609,288,584,288,544) +lt(288,221) +ct(288,171,283,131,272,100) +ct(261,69,242,42,215,19) +ct(189,-3,156,-15,119,-15) +ct(88,-15,64,-7,46,7) +ct(29,22,20,40,20,59) +ct(20,75,24,87,32,95) +ct(42,105,55,110,70,110) +ct(80,110,90,107,98,100) +ct(106,93,117,75,129,45) +ct(137,27,146,19,158,19) +ct(167,19,175,24,183,35) +ct(190,46,194,65,194,92) +lt(194,544) +ct(194,578,192,600,188,611) +ct(184,619,177,626,167,632) +ct(153,640,138,644,123,644) +lt(99,644) + )cp +endchar; + +beginchar(75,722*FX#,662*FY#,0*FY#); +"K"; +dr +ah((298,367) +lt(542,124) +ct(583,84,617,57,645,42) +ct(673,28,702,20,730,18) +lt(730,0) +lt(415,0) +lt(415,18) +ct(434,18,447,21,456,27) +ct(464,33,468,41,468,48) +ct(468,56,467,63,464,69) +ct(461,76,450,87,433,104) +lt(205,330) +lt(205,117) +ct(205,83,207,60,211,50) +ct(214,42,221,35,231,29) +ct(245,21,260,18,276,18) +lt(298,18) +lt(298,0) +lt(16,0) +lt(16,18) +lt(40,18) +ct(67,18,87,25,99,41) +ct(107,51,111,77,111,117) +lt(111,544) +ct(111,578,108,600,104,611) +ct(101,619,94,626,84,632) +ct(70,640,55,644,40,644) +lt(16,644) +lt(16,662) +lt(298,662) +lt(298,644) +lt(276,644) +ct(260,644,245,640,231,632) +ct(221,627,214,619,210,609) +ct(207,598,205,577,205,544) +lt(205,342) +ct(211,348,233,368,271,404) +ct(367,492,426,551,447,581) +ct(455,594,460,605,460,615) +ct(460,623,457,629,450,635) +ct(443,641,431,644,415,644) +lt(400,644) +lt(400,662) +lt(643,662) +lt(643,644) +ct(629,643,616,641,604,638) +ct(592,634,578,627,561,617) +ct(544,607,523,590,499,567) +ct(491,561,458,527,399,467) +lt(298,367) + )cp +endchar; + +beginchar(76,610*FX#,662*FY#,0*FY#); +"L"; +dr +ah((573,183) +lt(589,179) +lt(532,0) +lt(20,0) +lt(20,18) +lt(44,18) +ct(72,18,92,27,104,45) +ct(111,55,115,79,115,117) +lt(115,544) +ct(115,585,110,611,101,622) +ct(88,636,69,644,44,644) +lt(20,644) +lt(20,662) +lt(319,662) +lt(319,644) +ct(284,644,260,641,245,634) +ct(231,627,222,618,216,608) +ct(211,597,208,573,208,533) +lt(208,117) +ct(208,90,210,72,216,62) +ct(220,55,226,50,234,46) +ct(243,43,268,41,311,41) +lt(359,41) +ct(410,41,445,45,466,53) +ct(486,60,505,73,522,93) +ct(539,112,556,142,573,183) + )cp +endchar; + +beginchar(77,889*FX#,662*FY#,0*FY#); +"M"; +dr +ah((409,0) +lt(153,557) +lt(153,114) +ct(153,73,157,48,166,38) +ct(178,24,197,18,223,18) +lt(247,18) +lt(247,0) +lt(16,0) +lt(16,18) +lt(40,18) +ct(68,18,87,26,99,43) +ct(106,53,110,77,110,114) +lt(110,547) +ct(110,576,106,597,100,610) +ct(96,620,87,628,75,634) +ct(63,640,43,644,16,644) +lt(16,662) +lt(204,662) +lt(444,144) +lt(680,662) +lt(868,662) +lt(868,644) +lt(845,644) +ct(816,644,796,635,785,618) +ct(777,608,774,584,774,547) +lt(774,114) +ct(774,73,778,48,788,38) +ct(800,24,819,18,845,18) +lt(868,18) +lt(868,0) +lt(586,0) +lt(586,18) +lt(610,18) +ct(638,18,657,26,669,43) +ct(676,53,680,77,680,114) +lt(680,557) +lt(425,0) +lt(409,0) + )cp +endchar; + +beginchar(78,722*FX#,662*FY#,10*FY#); +"N"; +dr +ah((-13,662) +lt(166,662) +lt(571,165) +lt(571,547) +ct(571,587,566,613,557,623) +ct(545,637,526,644,500,644) +lt(477,644) +lt(477,662) +lt(708,662) +lt(708,644) +lt(684,644) +ct(656,644,636,635,625,618) +ct(617,608,614,584,614,547) +lt(614,-10) +lt(596,-10) +lt(160,522) +lt(160,114) +ct(160,73,164,48,173,38) +ct(185,24,204,18,230,18) +lt(253,18) +lt(253,0) +lt(23,0) +lt(23,18) +lt(46,18) +ct(74,18,94,26,106,43) +ct(113,53,117,77,117,114) +lt(117,575) +ct(97,597,83,612,73,619) +ct(63,626,48,633,29,639) +ct(19,642,5,644,-13,644) +lt(-13,662) + )cp +chp[78]:=currentpicture; +endchar; + +beginchar(79,722*FX#,677*FY#,15*FY#); +"O"; +dr +ah((365,677) +ct(451,677,526,644,589,579) +ct(652,514,683,432,683,334) +ct(683,234,651,150,588,84) +ct(524,18,448,-15,357,-15) +ct(266,-15,190,17,128,82) +ct(66,146,35,230,35,333) +ct(35,438,70,524,142,590) +ct(204,648,278,677,365,677) + )cp +dr +ah((356,641) +ct(296,641,249,619,213,575) +ct(168,520,146,440,146,335) +ct(146,227,169,143,216,85) +ct(251,41,298,19,356,19) +ct(419,19,470,43,510,92) +ct(551,140,571,217,571,321) +ct(571,434,548,519,504,575) +ct(468,619,419,641,356,641) + )cp +chp[79]:=currentpicture; +endchar; + +beginchar(80,556*FX#,662*FY#,0*FY#); +"P"; +dr +ah((205,310) +lt(205,117) +ct(205,75,209,49,218,39) +ct(230,25,249,18,274,18) +lt(300,18) +lt(300,0) +lt(16,0) +lt(16,18) +lt(41,18) +ct(69,18,89,27,101,45) +ct(107,55,111,79,111,117) +lt(111,544) +ct(111,586,106,612,98,622) +ct(85,636,66,644,41,644) +lt(16,644) +lt(16,662) +lt(259,662) +ct(318,662,365,656,399,643) +ct(433,631,462,611,485,582) +ct(509,553,520,518,520,479) +ct(520,424,503,381,467,347) +ct(431,313,381,296,316,296) +ct(300,296,283,297,264,299) +ct(246,302,226,305,205,310) + )cp +dr +ah((205,337) +ct(222,334,237,332,250,330) +ct(264,328,275,328,285,328) +ct(319,328,348,341,372,367) +ct(397,393,409,427,409,469) +ct(409,497,403,524,392,549) +ct(380,573,363,592,342,604) +ct(320,616,296,622,269,622) +ct(252,622,231,619,205,613) +lt(205,337) + )cp +endchar; + +beginchar(81,722*FX#,677*FY#,195*FY#); +"Q"; +dr +ah((440,-7) +ct(473,-64,509,-106,548,-133) +ct(586,-160,630,-176,679,-180) +lt(679,-195) +ct(634,-194,586,-185,535,-168) +ct(484,-152,436,-129,390,-100) +ct(344,-71,305,-40,271,-7) +ct(224,11,187,30,160,52) +ct(120,84,90,123,68,169) +ct(46,215,35,269,35,332) +ct(35,431,67,513,131,579) +ct(195,644,273,677,364,677) +ct(450,677,525,644,589,578) +ct(652,513,684,430,684,330) +ct(684,249,661,178,616,117) +ct(571,55,512,14,440,-7) + )cp +dr +ah((358,639) +ct(298,639,251,618,215,576) +ct(169,522,146,441,146,332) +ct(146,224,169,142,216,84) +ct(252,40,299,18,358,18) +ct(419,18,468,40,506,84) +ct(550,137,572,215,572,318) +ct(572,397,560,464,536,518) +ct(517,559,492,590,462,610) +ct(431,629,396,639,358,639) + )cp +endchar; + +beginchar(82,666*FX#,662*FY#,0*FY#); +"R"; +dr +ah((675,0) +lt(499,0) +lt(274,309) +ct(258,308,244,308,234,308) +ct(230,308,225,308,220,308) +ct(215,309,210,309,205,309) +lt(205,117) +ct(205,75,209,49,219,39) +ct(231,25,249,18,274,18) +lt(300,18) +lt(300,0) +lt(17,0) +lt(17,18) +lt(41,18) +ct(69,18,89,27,102,45) +ct(108,55,112,79,112,117) +lt(112,544) +ct(112,586,107,612,98,622) +ct(85,636,66,644,41,644) +lt(17,644) +lt(17,662) +lt(258,662) +ct(328,662,380,656,413,646) +ct(447,636,475,617,498,590) +ct(522,562,533,529,533,491) +ct(533,451,520,415,493,385) +ct(467,355,426,334,370,322) +lt(507,132) +ct(538,88,565,59,587,45) +ct(610,31,639,21,675,18) +lt(675,0) + )cp +dr +ah((205,340) +ct(211,340,217,340,221,340) +ct(226,339,229,339,232,339) +ct(296,339,343,353,375,380) +ct(407,408,423,443,423,485) +ct(423,526,410,560,385,586) +ct(359,612,324,625,282,625) +ct(262,625,237,621,205,615) +lt(205,340) + )cp +endchar; + +beginchar(83,556*FX#,677*FY#,15*FY#); +"S"; +dr +ah((458,677) +lt(458,448) +lt(440,448) +ct(434,492,424,527,408,553) +ct(393,579,372,599,344,615) +ct(316,630,287,638,257,638) +ct(223,638,195,627,173,607) +ct(151,586,140,562,140,536) +ct(140,516,147,497,161,481) +ct(181,456,229,423,305,383) +ct(367,350,409,325,431,307) +ct(454,289,471,268,484,244) +ct(496,220,502,195,502,168) +ct(502,118,482,75,444,39) +ct(405,3,355,-15,293,-15) +ct(274,-15,256,-13,239,-10) +ct(229,-9,208,-3,177,7) +ct(145,17,125,22,116,22) +ct(108,22,102,20,97,15) +ct(92,10,89,0,86,-15) +lt(68,-15) +lt(68,211) +lt(86,211) +ct(95,164,106,128,121,105) +ct(135,81,157,62,186,46) +ct(216,30,248,22,283,22) +ct(324,22,356,33,380,55) +ct(403,76,415,102,415,131) +ct(415,147,411,164,402,180) +ct(393,197,379,212,360,227) +ct(347,236,312,257,256,289) +ct(199,321,159,346,135,365) +ct(111,384,93,404,81,427) +ct(68,450,62,475,62,502) +ct(62,550,80,591,117,625) +ct(153,660,200,677,256,677) +ct(291,677,328,668,368,651) +ct(386,643,398,639,406,639) +ct(415,639,422,641,427,646) +ct(432,651,437,661,440,677) +lt(458,677) + )cp +chp[83]:=currentpicture; +endchar; + +beginchar(84,610*FX#,662*FY#,0*FY#); +"T"; +dr +ah((578,662) +lt(585,506) +lt(567,506) +ct(563,533,558,553,552,565) +ct(542,584,529,598,512,607) +ct(495,616,473,620,446,620) +lt(353,620) +lt(353,114) +ct(353,73,357,48,366,38) +ct(378,24,397,18,423,18) +lt(446,18) +lt(446,0) +lt(165,0) +lt(165,18) +lt(188,18) +ct(216,18,236,26,248,43) +ct(255,53,259,77,259,114) +lt(259,620) +lt(179,620) +ct(148,620,126,617,113,613) +ct(96,607,82,595,70,578) +ct(58,560,51,536,48,506) +lt(30,506) +lt(38,662) +lt(578,662) + )cp +endchar; + +beginchar(85,722*FX#,662*FY#,15*FY#); +"U"; +dr +ah((477,644) +lt(477,662) +lt(711,662) +lt(711,644) +lt(686,644) +ct(660,644,640,633,626,611) +ct(619,601,616,577,616,541) +lt(616,272) +ct(616,206,609,154,596,117) +ct(583,81,557,49,518,23) +ct(480,-2,427,-15,361,-15) +ct(289,-15,234,-3,196,21) +ct(159,47,132,80,117,123) +ct(106,151,101,206,101,286) +lt(101,544) +ct(101,585,95,612,84,625) +ct(73,637,55,644,30,644) +lt(5,644) +lt(5,662) +lt(291,662) +lt(291,644) +lt(266,644) +ct(238,644,219,635,207,618) +ct(199,606,195,581,195,544) +lt(195,256) +ct(195,230,197,201,202,167) +ct(207,134,215,108,228,90) +ct(240,71,258,56,281,44) +ct(304,32,333,26,367,26) +ct(410,26,449,35,483,54) +ct(517,73,540,97,553,127) +ct(565,156,572,206,572,276) +lt(572,544) +ct(572,585,567,611,558,622) +ct(545,636,526,644,501,644) +lt(477,644) + )cp +chp[85]:=currentpicture; +endchar; + +beginchar(86,722*FX#,662*FY#,15*FY#); +"V"; +dr +ah((709,662) +lt(709,644) +ct(685,639,668,631,656,621) +ct(638,605,623,580,610,548) +lt(379,-15) +lt(361,-15) +lt(113,555) +ct(100,584,91,602,86,609) +ct(78,619,68,627,56,633) +ct(45,638,28,642,8,644) +lt(8,662) +lt(279,662) +lt(279,644) +ct(248,641,228,635,219,628) +ct(210,620,206,611,206,599) +ct(206,583,213,557,228,523) +lt(396,135) +lt(553,518) +ct(568,556,576,582,576,597) +ct(576,606,571,615,562,624) +ct(552,632,536,638,514,642) +ct(512,642,509,643,505,644) +lt(505,662) +lt(709,662) + )cp +endchar; + +beginchar(87,943*FX#,662*FY#,15*FY#); +"W"; +dr +ah((936,662) +lt(936,644) +ct(918,644,904,640,894,634) +ct(883,628,873,617,863,600) +ct(856,588,846,561,832,518) +lt(647,-15) +lt(628,-15) +lt(477,408) +lt(327,-15) +lt(310,-15) +lt(113,534) +ct(98,575,89,599,85,607) +ct(78,619,70,628,58,635) +ct(47,641,32,644,13,644) +lt(13,662) +lt(258,662) +lt(258,644) +lt(246,644) +ct(229,644,216,640,207,632) +ct(197,624,193,615,193,604) +ct(193,592,200,565,214,525) +lt(345,153) +lt(455,469) +lt(435,525) +lt(419,569) +ct(412,585,404,600,396,612) +ct(392,618,387,624,381,628) +ct(373,634,364,638,356,641) +ct(350,643,340,644,327,644) +lt(327,662) +lt(585,662) +lt(585,644) +lt(567,644) +ct(549,644,536,640,527,632) +ct(519,624,515,613,515,600) +ct(515,583,522,554,537,513) +lt(664,153) +lt(790,518) +ct(804,558,811,586,811,602) +ct(811,610,809,617,804,623) +ct(799,630,793,634,786,637) +ct(774,641,758,644,738,644) +lt(738,662) +lt(936,662) + )cp +endchar; + +beginchar(88,722*FX#,662*FY#,0*FY#); +"X"; +dr +ah((408,366) +lt(550,154) +ct(589,96,618,59,637,43) +ct(656,28,681,19,710,18) +lt(710,0) +lt(426,0) +lt(426,18) +ct(444,18,458,19,468,23) +ct(475,26,480,31,485,37) +ct(489,43,491,49,491,55) +ct(491,62,489,70,487,78) +ct(484,83,475,97,460,121) +lt(348,291) +lt(209,113) +ct(194,94,186,81,183,75) +ct(180,69,178,62,178,55) +ct(178,45,183,36,191,29) +ct(200,22,217,19,242,18) +lt(242,0) +lt(7,0) +lt(7,18) +ct(23,19,38,22,50,28) +ct(70,36,89,48,107,62) +ct(126,76,146,98,170,128) +lt(326,325) +lt(196,516) +ct(160,568,130,602,105,618) +ct(81,634,52,643,20,644) +lt(20,662) +lt(326,662) +lt(326,644) +ct(300,643,282,638,273,631) +ct(263,623,258,615,258,606) +ct(258,594,266,576,282,553) +lt(383,401) +lt(501,550) +ct(515,568,523,580,526,586) +ct(529,593,531,600,531,606) +ct(531,613,529,619,525,625) +ct(520,631,514,636,506,639) +ct(499,642,483,643,460,644) +lt(460,662) +lt(695,662) +lt(695,644) +ct(676,642,661,639,649,635) +ct(632,627,616,617,601,604) +ct(586,592,566,568,539,534) +lt(408,366) + )cp +endchar; + +beginchar(89,722*FX#,662*FY#,0*FY#); +"Y"; +dr +ah((476,662) +lt(707,662) +lt(707,644) +lt(694,644) +ct(686,644,673,640,657,632) +ct(641,625,626,614,613,600) +ct(599,586,583,563,563,532) +lt(404,280) +lt(404,114) +ct(404,73,408,48,417,38) +ct(429,24,449,18,476,18) +lt(498,18) +lt(498,0) +lt(216,0) +lt(216,18) +lt(240,18) +ct(268,18,287,26,299,43) +ct(306,53,310,77,310,114) +lt(310,271) +lt(128,548) +ct(107,581,92,601,85,609) +ct(77,618,61,627,37,639) +ct(30,642,21,644,9,644) +lt(9,662) +lt(292,662) +lt(292,644) +lt(277,644) +ct(262,644,248,640,235,633) +ct(222,626,216,615,216,601) +ct(216,589,226,567,246,537) +lt(384,324) +lt(514,528) +ct(533,558,543,581,543,596) +ct(543,605,541,613,536,621) +ct(531,628,524,633,516,637) +ct(507,642,494,644,476,644) +lt(476,662) + )cp +chp[89]:=currentpicture; +endchar; + +beginchar(90,610*FX#,662*FY#,0*FY#); +"Z"; +dr +ah((575,662) +lt(140,40) +lt(411,40) +ct(453,40,485,49,507,67) +ct(529,85,549,122,566,178) +lt(583,175) +lt(551,0) +lt(12,0) +lt(12,18) +lt(437,622) +lt(225,622) +ct(190,622,164,618,149,611) +ct(133,603,121,592,113,577) +ct(104,563,97,536,90,496) +lt(71,496) +lt(85,662) +lt(575,662) + )cp +chp[90]:=currentpicture; +endchar; + +beginchar(91,333*FX#,677*FY#,198*FY#); +"bracketleft"; +dr +ah((296,-198) +lt(82,-198) +lt(82,677) +lt(296,677) +lt(296,638) +lt(155,638) +lt(155,-160) +lt(296,-160) +lt(296,-198) + )cp +endchar; + +beginchar(148,277*FX#,694*FY#,13*FY#); +"backslash"; +dr +ah((40,694) +lt(279,-13) +lt(240,-13) +lt(1,694) +lt(40,694) + )cp +endchar; + +beginchar(93,333*FX#,677*FY#,198*FY#); +"bracketright"; +dr +ah((36,677) +lt(251,677) +lt(251,-198) +lt(36,-198) +lt(36,-160) +lt(178,-160) +lt(178,638) +lt(36,638) +lt(36,677) + )cp +endchar; + +beginchar(143,469*FX#,675*FY#,0*FY#); +"asciicircum"; +dr +ah((243,675) +lt(450,325) +lt(405,325) +lt(234,611) +lt(63,325) +lt(18,325) +lt(228,675) +lt(243,675) + )cp +endchar; + +beginchar(149,500*FX#,0*FY#,215*FY#); +"underscore"; +dr +ah((508,-215) +lt(-8,-215) +lt(-8,-174) +lt(508,-174) +lt(508,-215) + )cp +endchar; + +beginchar(18,333*FX#,678*FY#,0*FY#); +"grave"; +dr +ah((57,678) +lt(166,678) +lt(218,510) +lt(201,510) +lt(57,678) + )cp +chp[193]:=currentpicture; +endchar; + +beginchar(97,443*FX#,460*FY#,9*FY#); +"a"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +chp[97]:=currentpicture; +endchar; + +beginchar(98,500*FX#,694*FY#,13*FY#); +"b"; +dr +ah((153,370) +ct(196,430,243,460,293,460) +ct(339,460,379,440,414,401) +ct(448,362,465,308,465,240) +ct(465,160,438,96,386,48) +ct(340,7,290,-13,234,-13) +ct(208,-13,182,-8,155,0) +ct(128,9,101,24,73,42) +lt(73,506) +ct(73,557,72,588,69,600) +ct(67,611,63,619,58,624) +ct(52,628,46,630,38,630) +ct(28,630,17,627,4,622) +lt(-2,639) +lt(131,694) +lt(153,694) +lt(153,370) + )cp +dr +ah((153,338) +lt(153,71) +ct(170,55,187,42,205,34) +ct(223,26,241,21,259,21) +ct(289,21,316,38,342,70) +ct(368,103,380,150,380,212) +ct(380,270,368,314,342,344) +ct(316,375,287,391,255,391) +ct(237,391,220,386,203,377) +ct(190,371,173,358,153,338) + )cp +endchar; + +beginchar(99,443*FX#,460*FY#,13*FY#); +"c"; +dr +ah((411,169) +ct(399,111,375,65,340,33) +ct(305,2,266,-13,223,-13) +ct(172,-13,128,7,90,50) +ct(53,92,34,150,34,223) +ct(34,293,55,350,96,394) +ct(138,438,188,460,247,460) +ct(291,460,327,448,355,425) +ct(384,402,398,378,398,353) +ct(398,340,394,330,386,322) +ct(378,315,367,311,353,311) +ct(333,311,319,317,309,330) +ct(304,336,300,349,298,369) +ct(296,388,290,402,278,413) +ct(266,422,251,427,231,427) +ct(198,427,172,415,152,391) +ct(126,359,113,317,113,265) +ct(113,211,126,164,152,123) +ct(178,82,214,62,258,62) +ct(290,62,318,73,344,95) +ct(362,109,379,136,396,176) +lt(411,169) + )cp +chp[99]:=currentpicture; +endchar; + +beginchar(100,500*FX#,694*FY#,13*FY#); +"d"; +dr +ah((347,50) +ct(325,27,304,11,283,1) +ct(262,-8,239,-13,215,-13) +ct(166,-13,124,6,87,47) +ct(51,88,33,140,33,205) +ct(33,269,53,327,93,381) +ct(134,434,186,460,249,460) +ct(288,460,321,447,347,423) +lt(347,505) +ct(347,556,345,588,343,600) +ct(341,611,337,619,332,624) +ct(326,628,320,630,312,630) +ct(303,630,292,627,278,622) +lt(272,639) +lt(405,694) +lt(427,694) +lt(427,177) +ct(427,124,428,92,431,81) +ct(433,69,437,61,443,57) +ct(448,52,454,50,461,50) +ct(470,50,482,52,497,58) +lt(502,41) +lt(369,-13) +lt(347,-13) +lt(347,50) + )cp +dr +ah((347,84) +lt(347,314) +ct(345,337,339,357,329,375) +ct(319,393,306,407,290,416) +ct(274,426,258,430,243,430) +ct(214,430,188,417,166,392) +ct(136,358,122,308,122,243) +ct(122,177,136,127,165,92) +ct(194,57,226,40,261,40) +ct(290,40,319,54,347,84) + )cp +endchar; + +beginchar(101,443*FX#,460*FY#,13*FY#); +"e"; +dr +ah((106,278) +ct(105,212,121,160,154,122) +ct(186,84,225,65,269,65) +ct(298,65,324,73,345,90) +ct(367,106,385,133,400,172) +lt(415,163) +ct(408,118,388,77,355,41) +ct(323,4,281,-13,232,-13) +ct(178,-13,132,7,94,49) +ct(56,90,37,147,37,217) +ct(37,294,56,353,95,396) +ct(135,439,184,460,243,460) +ct(293,460,334,444,367,411) +ct(399,378,415,334,415,278) +lt(106,278) + )cp +dr +ah((106,307) +lt(313,307) +ct(311,335,308,355,303,367) +ct(295,385,282,400,266,410) +ct(250,421,233,426,216,426) +ct(189,426,165,415,143,394) +ct(122,373,110,344,106,307) + )cp +chp[101]:=currentpicture; +endchar; + +beginchar(102,333*FX#,693*FY#,0*FY#); +"f"; +dr +ah((206,412) +lt(206,118) +ct(206,76,210,49,219,39) +ct(231,24,247,17,268,17) +lt(308,17) +lt(308,0) +lt(41,0) +lt(41,17) +lt(61,17) +ct(74,17,86,20,97,27) +ct(107,33,115,42,119,53) +ct(123,64,125,86,125,118) +lt(125,412) +lt(38,412) +lt(38,447) +lt(125,447) +lt(125,476) +ct(125,521,132,558,146,589) +ct(161,620,183,645,212,664) +ct(242,683,275,693,312,693) +ct(346,693,377,682,406,660) +ct(424,645,434,628,434,610) +ct(434,601,430,591,421,583) +ct(413,574,404,570,394,570) +ct(387,570,379,572,370,578) +ct(362,583,352,595,340,613) +ct(328,630,317,642,307,648) +ct(296,654,285,658,273,658) +ct(258,658,245,654,235,646) +ct(224,638,217,625,212,609) +ct(208,592,206,549,206,479) +lt(206,447) +lt(321,447) +lt(321,412) +lt(206,412) + )cp +endchar; + +beginchar(103,500*FX#,460*FY#,215*FY#); +"g"; +dr +ah((150,163) +ct(123,176,102,195,87,218) +ct(73,242,65,269,65,298) +ct(65,342,82,380,115,412) +ct(149,444,192,460,244,460) +ct(286,460,323,449,354,429) +lt(449,429) +ct(463,429,471,428,474,427) +ct(476,427,478,425,479,423) +ct(480,420,481,415,481,408) +ct(481,399,480,393,479,390) +ct(478,388,476,387,474,386) +ct(471,385,463,385,449,385) +lt(391,385) +ct(409,361,418,331,418,295) +ct(418,253,402,218,371,188) +ct(339,158,296,144,242,144) +ct(220,144,197,147,174,153) +ct(160,141,150,130,145,121) +ct(140,112,138,104,138,97) +ct(138,92,140,86,146,81) +ct(151,76,162,72,177,70) +ct(186,68,209,67,246,66) +ct(312,64,356,62,376,60) +ct(406,55,430,44,448,26) +ct(467,8,476,-14,476,-41) +ct(476,-77,458,-112,424,-144) +ct(373,-191,307,-215,225,-215) +ct(162,-215,109,-201,66,-173) +ct(41,-156,29,-139,29,-122) +ct(29,-114,31,-106,35,-99) +ct(40,-87,51,-70,69,-48) +ct(71,-45,87,-28,119,3) +ct(102,13,90,23,83,31) +ct(76,38,72,48,72,58) +ct(72,69,77,82,86,98) +ct(95,113,117,135,150,163) + )cp +dr +ah((235,437) +ct(211,437,191,427,175,408) +ct(159,388,150,359,150,319) +ct(150,267,161,228,184,200) +ct(200,178,222,167,248,167) +ct(273,167,293,177,309,195) +ct(325,214,333,243,333,283) +ct(333,334,321,374,299,404) +ct(282,426,261,437,235,437) + )cp +dr +ah((145,0) +ct(130,-16,119,-32,111,-46) +ct(103,-60,99,-73,99,-85) +ct(99,-101,108,-114,127,-126) +ct(159,-146,207,-157,269,-157) +ct(327,-157,370,-146,398,-126) +ct(426,-105,440,-83,440,-60) +ct(440,-42,431,-30,415,-23) +ct(398,-16,364,-12,314,-11) +ct(241,-9,185,-5,145,0) + )cp +endchar; + +beginchar(104,500*FX#,694*FY#,0*FY#); +"h"; +dr +ah((162,694) +lt(162,367) +ct(198,406,227,432,248,443) +ct(269,454,290,460,312,460) +ct(337,460,359,453,377,439) +ct(395,425,409,403,417,373) +ct(423,352,427,314,427,259) +lt(427,101) +ct(427,72,429,52,434,42) +ct(437,35,442,28,450,24) +ct(458,19,472,17,493,17) +lt(493,0) +lt(273,0) +lt(273,17) +lt(284,17) +ct(305,17,319,20,327,27) +ct(335,33,341,42,344,55) +ct(345,59,346,75,346,101) +lt(346,259) +ct(346,308,343,340,338,355) +ct(333,370,325,382,314,389) +ct(303,397,290,401,274,401) +ct(258,401,241,397,224,388) +ct(207,380,186,363,162,337) +lt(162,101) +ct(162,70,164,51,167,43) +ct(171,36,177,30,186,25) +ct(196,20,212,17,234,17) +lt(234,0) +lt(13,0) +lt(13,17) +ct(32,17,48,20,60,26) +ct(66,30,71,36,75,45) +ct(79,54,81,73,81,101) +lt(81,505) +ct(81,556,80,588,77,600) +ct(75,611,71,619,66,624) +ct(61,628,54,630,46,630) +ct(39,630,28,627,13,622) +lt(6,639) +lt(140,694) +lt(162,694) + )cp +endchar; + +beginchar(105,277*FX#,694*FY#,0*FY#); +"i"; +dr +ah((145,694) +ct(158,694,170,689,179,679) +ct(189,670,194,658,194,645) +ct(194,631,189,619,179,609) +ct(170,600,158,595,145,595) +ct(131,595,119,600,109,609) +ct(100,619,95,631,95,645) +ct(95,658,100,670,109,679) +ct(119,689,131,694,145,694) + )cp +dr +ah((185,460) +lt(185,101) +ct(185,73,187,54,191,45) +ct(195,35,201,28,209,24) +ct(217,19,232,17,253,17) +lt(253,0) +lt(36,0) +lt(36,17) +ct(57,17,72,19,80,23) +ct(87,28,93,35,97,44) +ct(102,54,104,73,104,101) +lt(104,273) +ct(104,321,102,353,100,367) +ct(97,378,94,385,89,389) +ct(84,393,77,395,69,395) +ct(59,395,48,392,36,388) +lt(29,405) +lt(164,460) +lt(185,460) + )cp +endchar; + +beginchar(106,277*FX#,694*FY#,215*FY#); +"j"; +dr +ah((144,694) +ct(158,694,170,689,180,680) +ct(189,670,194,658,194,644) +ct(194,630,189,619,180,609) +ct(170,599,158,594,144,594) +ct(130,594,119,599,109,609) +ct(99,619,94,630,94,644) +ct(94,658,99,670,109,680) +ct(119,689,130,694,144,694) + )cp +dr +ah((186,460) +lt(186,10) +ct(186,-66,170,-123,137,-160) +ct(105,-197,62,-215,10,-215) +ct(-18,-215,-40,-210,-55,-199) +ct(-69,-188,-76,-177,-76,-166) +ct(-76,-155,-72,-145,-64,-137) +ct(-56,-129,-47,-125,-36,-125) +ct(-27,-125,-18,-127,-10,-131) +ct(-5,-133,5,-141,21,-156) +ct(37,-170,50,-177,61,-177) +ct(68,-177,76,-174,83,-168) +ct(91,-162,97,-152,100,-137) +ct(104,-123,105,-93,105,-45) +lt(105,272) +ct(105,321,103,353,101,367) +ct(99,377,95,385,90,389) +ct(85,393,79,395,70,395) +ct(61,395,50,392,37,388) +lt(30,405) +lt(165,460) +lt(186,460) + )cp +endchar; + +beginchar(107,500*FX#,694*FY#,0*FY#); +"k"; +dr +ah((163,694) +lt(163,249) +lt(277,353) +ct(301,375,315,389,319,395) +ct(321,398,323,402,323,406) +ct(323,413,320,418,315,423) +ct(309,428,300,430,288,431) +lt(288,447) +lt(482,447) +lt(482,431) +ct(456,430,434,426,416,419) +ct(398,411,379,398,357,379) +lt(243,273) +lt(357,128) +ct(389,88,410,62,422,52) +ct(437,36,451,26,463,22) +ct(471,18,485,17,505,17) +lt(505,0) +lt(288,0) +lt(288,17) +ct(300,17,309,19,313,23) +ct(318,26,320,31,320,37) +ct(320,44,313,56,300,73) +lt(163,249) +lt(163,100) +ct(163,71,165,52,169,43) +ct(173,34,179,27,187,23) +ct(194,20,210,17,235,17) +lt(235,0) +lt(8,0) +lt(8,17) +ct(30,17,47,19,59,25) +ct(65,29,71,34,75,42) +ct(79,52,82,71,82,98) +lt(82,505) +ct(82,557,81,588,79,600) +ct(76,611,73,619,67,624) +ct(62,628,55,630,47,630) +ct(40,630,30,627,16,622) +lt(8,639) +lt(141,694) +lt(163,694) + )cp +endchar; + +beginchar(108,277*FX#,694*FY#,0*FY#); +"l"; +dr +ah((185,694) +lt(185,101) +ct(185,73,187,54,191,45) +ct(195,36,201,29,209,24) +ct(218,19,234,17,257,17) +lt(257,0) +lt(38,0) +lt(38,17) +ct(58,17,72,19,80,23) +ct(87,28,93,35,97,44) +ct(101,54,104,73,104,101) +lt(104,507) +ct(104,557,102,588,100,600) +ct(98,611,94,619,89,624) +ct(84,628,78,630,70,630) +ct(61,630,50,627,38,622) +lt(29,639) +lt(163,694) +lt(185,694) + )cp +endchar; + +beginchar(109,777*FX#,460*FY#,0*FY#); +"m"; +dr +ah((164,365) +ct(196,397,215,416,221,421) +ct(236,433,252,443,269,450) +ct(285,457,302,460,319,460) +ct(347,460,371,452,391,436) +ct(411,419,425,396,432,365) +ct(465,404,493,429,517,442) +ct(540,454,563,460,588,460) +ct(612,460,633,454,651,442) +ct(670,429,684,409,695,382) +ct(702,363,706,333,706,293) +lt(706,101) +ct(706,73,708,53,712,43) +ct(715,36,721,30,730,25) +ct(739,20,753,17,773,17) +lt(773,0) +lt(552,0) +lt(552,17) +lt(562,17) +ct(580,17,595,20,606,28) +ct(614,33,619,41,623,53) +ct(624,59,625,75,625,101) +lt(625,293) +ct(625,329,620,355,611,370) +ct(598,390,578,401,550,401) +ct(533,401,516,397,498,388) +ct(481,380,460,364,435,340) +lt(434,335) +lt(435,314) +lt(435,101) +ct(435,70,437,51,440,43) +ct(444,36,450,30,459,25) +ct(469,20,485,17,508,17) +lt(508,0) +lt(282,0) +lt(282,17) +ct(306,17,323,20,333,26) +ct(342,32,348,41,352,52) +ct(353,58,354,74,354,101) +lt(354,293) +ct(354,329,348,356,338,372) +ct(324,392,304,403,278,403) +ct(260,403,243,398,226,389) +ct(199,374,178,358,164,340) +lt(164,101) +ct(164,71,166,52,170,43) +ct(174,35,180,28,188,24) +ct(196,19,212,17,236,17) +lt(236,0) +lt(15,0) +lt(15,17) +ct(36,17,50,19,58,24) +ct(66,28,72,35,77,45) +ct(81,54,83,73,83,101) +lt(83,271) +ct(83,320,81,352,79,367) +ct(76,377,73,385,68,389) +ct(63,393,56,395,48,395) +ct(38,395,27,392,15,388) +lt(8,405) +lt(143,460) +lt(164,460) +lt(164,365) + )cp +endchar; + +beginchar(110,500*FX#,460*FY#,0*FY#); +"n"; +dr +ah((161,365) +ct(213,428,263,460,311,460) +ct(335,460,356,454,374,442) +ct(392,429,406,409,416,381) +ct(423,361,427,331,427,291) +lt(427,101) +ct(427,72,429,53,434,43) +ct(437,35,443,28,451,24) +ct(459,19,474,17,495,17) +lt(495,0) +lt(274,0) +lt(274,17) +lt(283,17) +ct(304,17,319,20,327,27) +ct(335,33,341,42,344,55) +ct(345,59,346,75,346,101) +lt(346,284) +ct(346,324,341,354,330,372) +ct(320,391,302,400,277,400) +ct(238,400,199,378,161,336) +lt(161,101) +ct(161,70,162,51,166,44) +ct(171,35,177,28,185,24) +ct(193,19,209,17,234,17) +lt(234,0) +lt(13,0) +lt(13,17) +lt(22,17) +ct(45,17,61,23,69,34) +ct(77,46,81,68,81,101) +lt(81,267) +ct(81,320,79,353,77,365) +ct(74,376,71,384,66,389) +ct(61,393,54,395,45,395) +ct(36,395,25,392,13,388) +lt(5,405) +lt(140,460) +lt(161,460) +lt(161,365) + )cp +chp[110]:=currentpicture; +endchar; + +beginchar(111,500*FX#,460*FY#,13*FY#); +"o"; +dr +ah((250,460) +ct(317,460,371,434,413,383) +ct(447,339,465,288,465,231) +ct(465,191,455,151,436,110) +ct(417,69,390,38,357,17) +ct(323,-3,285,-13,244,-13) +ct(176,-13,123,13,83,66) +ct(49,111,33,162,33,219) +ct(33,260,43,301,64,341) +ct(84,382,111,412,144,431) +ct(177,450,212,460,250,460) + )cp +dr +ah((234,428) +ct(217,428,200,423,182,413) +ct(165,403,151,385,140,359) +ct(129,333,124,300,124,260) +ct(124,195,137,138,163,91) +ct(189,44,223,20,265,20) +ct(297,20,323,34,343,60) +ct(364,86,374,130,374,194) +ct(374,273,357,335,323,381) +ct(299,412,270,428,234,428) + )cp +chp[111]:=currentpicture; +endchar; + +beginchar(112,500*FX#,460*FY#,213*FY#); +"p"; +dr +ah((0,402) +lt(136,458) +lt(155,458) +lt(155,354) +ct(178,393,201,420,224,436) +ct(248,452,272,460,298,460) +ct(342,460,380,442,410,407) +ct(446,364,465,308,465,239) +ct(465,162,443,98,399,48) +ct(362,7,316,-13,261,-13) +ct(237,-13,216,-9,199,-3) +ct(185,1,171,10,155,25) +lt(155,-110) +ct(155,-140,157,-160,160,-168) +ct(164,-177,171,-183,180,-188) +ct(189,-193,206,-195,230,-195) +lt(230,-213) +lt(-3,-213) +lt(-3,-195) +lt(8,-195) +ct(26,-195,41,-192,54,-185) +ct(60,-181,65,-176,69,-168) +ct(72,-160,74,-139,74,-107) +lt(74,315) +ct(74,344,72,362,70,370) +ct(67,378,63,384,57,388) +ct(52,392,44,394,34,394) +ct(26,394,16,391,4,387) +lt(0,402) + )cp +dr +ah((155,325) +lt(155,158) +ct(155,122,156,98,159,86) +ct(164,68,175,51,193,37) +ct(210,22,233,15,260,15) +ct(292,15,319,27,339,53) +ct(365,86,378,133,378,193) +ct(378,261,363,314,333,351) +ct(312,376,287,389,259,389) +ct(243,389,228,385,213,377) +ct(201,371,181,354,155,325) + )cp +endchar; + +beginchar(113,500*FX#,460*FY#,213*FY#); +"q"; +dr +ah((427,460) +lt(427,-114) +ct(427,-143,429,-161,433,-169) +ct(437,-178,443,-184,451,-188) +ct(459,-193,475,-195,500,-195) +lt(500,-213) +lt(274,-213) +lt(274,-195) +lt(283,-195) +ct(301,-195,315,-192,325,-187) +ct(331,-184,336,-177,340,-168) +ct(344,-159,346,-141,346,-114) +lt(346,77) +ct(317,42,291,18,269,5) +ct(246,-7,223,-13,200,-13) +ct(156,-13,118,6,84,45) +ct(50,84,33,137,33,203) +ct(33,279,55,341,100,388) +ct(145,436,199,460,263,460) +ct(281,460,298,457,314,452) +ct(330,447,344,439,356,429) +ct(374,437,392,448,410,460) +lt(427,460) + )cp +dr +ah((346,108) +lt(346,318) +ct(346,342,343,361,337,375) +ct(330,389,319,401,303,411) +ct(286,421,268,426,248,426) +ct(211,426,180,410,154,379) +ct(128,348,115,302,115,239) +ct(115,179,128,133,155,102) +ct(181,70,213,55,250,55) +ct(270,55,287,59,302,67) +ct(317,75,332,89,346,108) + )cp +endchar; + +beginchar(114,333*FX#,460*FY#,0*FY#); +"r"; +dr +ah((162,460) +lt(162,359) +ct(199,426,237,460,277,460) +ct(295,460,310,454,321,444) +ct(333,433,339,420,339,406) +ct(339,393,335,382,326,374) +ct(318,365,308,360,296,360) +ct(284,360,272,366,258,377) +ct(243,388,233,394,226,394) +ct(220,394,213,390,207,384) +ct(192,370,177,348,162,318) +lt(162,104) +ct(162,79,165,60,171,48) +ct(175,39,183,32,193,26) +ct(204,20,220,17,240,17) +lt(240,0) +lt(11,0) +lt(11,17) +ct(33,17,50,20,62,28) +ct(70,33,75,41,79,53) +ct(80,58,81,74,81,100) +lt(81,273) +ct(81,326,80,357,78,366) +ct(76,376,72,384,66,388) +ct(60,393,53,395,45,395) +ct(35,395,23,392,11,388) +lt(6,405) +lt(141,460) +lt(162,460) + )cp +endchar; + +beginchar(115,389*FX#,460*FY#,13*FY#); +"s"; +dr +ah((320,460) +lt(320,308) +lt(304,308) +ct(291,355,275,388,256,405) +ct(237,423,212,431,182,431) +ct(159,431,141,425,127,413) +ct(113,401,106,388,106,373) +ct(106,355,111,339,122,326) +ct(132,312,152,298,183,284) +lt(254,249) +ct(320,217,354,174,354,122) +ct(354,81,338,48,307,23) +ct(277,-1,242,-13,204,-13) +ct(176,-13,145,-8,110,0) +ct(99,3,90,5,84,5) +ct(76,5,70,1,66,-6) +lt(50,-6) +lt(50,152) +lt(66,152) +ct(76,107,93,72,119,49) +ct(144,26,173,15,205,15) +ct(228,15,246,21,260,34) +ct(274,48,281,63,281,82) +ct(281,104,273,123,258,139) +ct(242,154,210,173,163,197) +ct(116,220,85,241,70,260) +ct(55,278,48,302,48,331) +ct(48,367,61,398,86,423) +ct(111,448,144,460,184,460) +ct(201,460,222,456,248,449) +ct(264,443,275,441,281,441) +ct(286,441,291,443,293,445) +ct(296,447,300,452,304,460) +lt(320,460) + )cp +chp[115]:=currentpicture; +endchar; + +beginchar(116,277*FX#,594*FY#,7*FY#); +"t"; +dr +ah((161,594) +lt(161,447) +lt(265,447) +lt(265,413) +lt(161,413) +lt(161,123) +ct(161,94,165,74,173,64) +ct(181,54,192,49,205,49) +ct(216,49,226,52,236,59) +ct(246,65,254,75,260,88) +lt(279,88) +ct(267,56,251,32,230,16) +ct(210,0,188,-7,166,-7) +ct(151,-7,136,-3,122,5) +ct(108,13,97,25,90,40) +ct(83,56,80,80,80,112) +lt(80,413) +lt(9,413) +lt(9,429) +ct(27,436,45,448,64,465) +ct(83,482,100,502,114,526) +ct(121,538,131,560,145,594) +lt(161,594) + )cp +endchar; + +beginchar(117,500*FX#,447*FY#,13*FY#); +"u"; +dr +ah((423,447) +lt(423,176) +ct(423,124,424,92,427,81) +ct(429,69,433,61,438,57) +ct(444,52,450,50,457,50) +ct(467,50,478,52,491,58) +lt(498,41) +lt(364,-13) +lt(342,-13) +lt(342,81) +ct(304,39,275,13,254,2) +ct(234,-8,213,-13,190,-13) +ct(165,-13,144,-6,125,8) +ct(107,22,94,41,87,63) +ct(80,86,76,118,76,160) +lt(76,360) +ct(76,381,74,396,69,404) +ct(65,412,58,418,49,423) +ct(40,427,24,429,0,429) +lt(0,447) +lt(157,447) +lt(157,147) +ct(157,106,164,78,179,65) +ct(193,52,211,46,231,46) +ct(245,46,261,50,279,59) +ct(297,68,318,85,342,109) +lt(342,363) +ct(342,388,338,405,328,414) +ct(319,423,300,428,270,429) +lt(270,447) +lt(423,447) + )cp +chp[117]:=currentpicture; +endchar; + +beginchar(118,500*FX#,447*FY#,13*FY#); +"v"; +dr +ah((8,447) +lt(218,447) +lt(218,429) +lt(205,429) +ct(192,429,182,426,176,419) +ct(169,413,166,405,166,395) +ct(166,383,169,369,176,354) +lt(280,107) +lt(384,363) +ct(391,381,395,395,395,405) +ct(395,409,394,413,392,416) +ct(388,421,383,424,378,426) +ct(372,428,361,429,344,429) +lt(344,447) +lt(490,447) +lt(490,429) +ct(473,427,461,424,455,418) +ct(443,408,433,392,424,370) +lt(266,-13) +lt(246,-13) +lt(86,363) +ct(79,381,72,393,65,401) +ct(59,409,51,415,41,420) +ct(35,423,24,426,8,429) +lt(8,447) + )cp +endchar; + +beginchar(119,722*FX#,447*FY#,13*FY#); +"w"; +dr +ah((6,447) +lt(193,447) +lt(193,429) +ct(176,427,165,424,159,419) +ct(154,415,151,408,151,398) +ct(151,388,154,376,160,362) +lt(255,104) +lt(352,314) +lt(326,380) +ct(318,399,307,412,295,420) +ct(288,424,275,427,255,429) +lt(255,447) +lt(468,447) +lt(468,429) +ct(444,427,428,423,418,416) +ct(412,410,409,402,409,391) +ct(409,384,410,377,413,371) +lt(514,114) +lt(608,362) +ct(614,379,618,393,618,404) +ct(618,410,615,416,609,420) +ct(602,425,590,428,571,429) +lt(571,447) +lt(712,447) +lt(712,429) +ct(684,424,663,405,650,371) +lt(500,-13) +lt(480,-13) +lt(369,271) +lt(238,-13) +lt(220,-13) +lt(77,362) +ct(67,386,58,402,49,410) +ct(40,418,25,424,6,429) +lt(6,447) + )cp +endchar; + +beginchar(120,500*FX#,447*FY#,0*FY#); +"x"; +dr +ah((13,447) +lt(223,447) +lt(223,429) +ct(210,429,200,426,195,422) +ct(190,417,187,411,187,404) +ct(187,396,192,384,204,368) +ct(207,362,212,354,220,343) +lt(252,292) +lt(289,343) +ct(312,375,324,396,324,404) +ct(324,411,321,417,315,422) +ct(310,426,301,429,289,429) +lt(289,447) +lt(440,447) +lt(440,429) +ct(424,427,410,423,398,416) +ct(382,404,361,380,333,343) +lt(272,262) +lt(383,102) +ct(411,62,430,38,442,31) +ct(454,23,469,18,487,17) +lt(487,0) +lt(276,0) +lt(276,17) +ct(290,17,302,20,311,27) +ct(317,31,320,37,320,45) +ct(320,52,309,71,289,102) +lt(223,197) +lt(151,102) +ct(129,72,118,54,118,49) +ct(118,41,122,34,129,28) +ct(136,21,147,18,162,17) +lt(162,0) +lt(16,0) +lt(16,17) +ct(28,19,38,23,47,29) +ct(59,38,79,62,109,102) +lt(203,226) +lt(118,349) +ct(94,384,75,406,62,415) +ct(49,424,33,429,13,429) +lt(13,447) + )cp +endchar; + +beginchar(121,500*FX#,447*FY#,215*FY#); +"y"; +dr +ah((5,447) +lt(214,447) +lt(214,429) +lt(204,429) +ct(189,429,178,426,171,419) +ct(163,413,160,405,160,395) +ct(160,382,165,365,176,343) +lt(285,117) +lt(385,364) +ct(390,377,393,390,393,404) +ct(393,410,392,414,390,417) +ct(387,421,383,423,377,426) +ct(372,428,362,429,348,429) +lt(348,447) +lt(494,447) +lt(494,429) +ct(482,427,472,425,466,421) +ct(459,417,452,410,444,399) +ct(441,394,436,381,428,361) +lt(246,-84) +ct(228,-127,205,-160,177,-182) +ct(148,-204,121,-215,94,-215) +ct(75,-215,59,-210,47,-199) +ct(34,-188,28,-175,28,-161) +ct(28,-147,33,-136,42,-128) +ct(51,-119,63,-115,79,-115) +ct(89,-115,104,-118,123,-126) +ct(135,-130,143,-133,147,-133) +ct(157,-133,167,-128,179,-118) +ct(190,-108,202,-89,214,-60) +lt(246,17) +lt(85,354) +ct(80,364,72,377,62,392) +ct(53,403,46,411,41,415) +ct(33,420,21,425,5,429) +lt(5,447) + )cp +chp[121]:=currentpicture; +endchar; + +beginchar(122,443*FX#,447*FY#,0*FY#); +"z"; +dr +ah((419,137) +lt(414,0) +lt(20,0) +lt(20,17) +lt(316,413) +lt(170,413) +ct(138,413,118,411,108,406) +ct(98,402,90,395,84,383) +ct(75,367,70,347,69,323) +lt(49,323) +lt(52,447) +lt(427,447) +lt(427,429) +lt(127,32) +lt(291,32) +ct(325,32,348,35,360,41) +ct(372,46,382,56,390,71) +ct(394,81,399,103,403,137) +lt(419,137) + )cp +chp[122]:=currentpicture; +endchar; + +beginchar(128,479*FX#,694*FY#,215*FY#); +"braceleft"; +dr +ah((410,-198) +lt(410,-215) +ct(356,-208,312,-186,278,-149) +ct(244,-113,227,-72,227,-27) +ct(227,-4,230,22,238,53) +ct(245,85,249,109,249,126) +ct(249,149,239,171,219,192) +ct(200,212,173,224,138,229) +lt(138,249) +ct(173,254,200,266,219,286) +ct(239,306,249,328,249,352) +ct(249,369,245,393,238,424) +ct(230,455,227,483,227,506) +ct(227,551,244,591,278,628) +ct(312,665,356,687,410,694) +lt(410,677) +ct(372,668,344,653,326,632) +ct(309,611,300,589,300,564) +ct(300,545,303,519,311,488) +ct(318,457,322,430,322,408) +ct(322,375,310,343,286,312) +ct(262,281,226,257,178,240) +ct(225,223,260,199,285,167) +ct(309,135,322,103,322,70) +ct(322,48,318,21,311,-9) +ct(303,-40,300,-66,300,-85) +ct(300,-110,309,-132,326,-153) +ct(344,-174,372,-189,410,-198) + )cp +endchar; + +beginchar(129,200*FX#,694*FY#,215*FY#); +"bar"; +dr +ah((119,694) +lt(119,-215) +lt(78,-215) +lt(78,694) +lt(119,694) + )cp +endchar; + +beginchar(130,479*FX#,694*FY#,215*FY#); +"braceright"; +dr +ah((86,677) +lt(86,694) +ct(140,687,184,665,218,628) +ct(253,592,270,551,270,506) +ct(270,482,266,455,258,424) +ct(251,393,247,369,247,352) +ct(247,329,257,307,277,286) +ct(296,266,324,254,358,249) +lt(358,229) +ct(324,224,296,212,277,192) +ct(257,171,247,149,247,126) +ct(247,109,251,85,258,53) +ct(266,22,270,-4,270,-27) +ct(270,-72,253,-112,218,-149) +ct(184,-186,140,-208,86,-215) +lt(86,-198) +ct(124,-189,152,-174,170,-153) +ct(187,-133,196,-110,196,-85) +ct(196,-66,193,-40,185,-9) +ct(178,21,174,48,174,70) +ct(174,103,186,135,210,166) +ct(234,197,270,221,318,238) +ct(271,255,236,279,211,311) +ct(186,343,174,375,174,408) +ct(174,430,178,457,185,488) +ct(193,519,196,545,196,564) +ct(196,589,187,611,170,632) +ct(152,653,124,668,86,677) + )cp +endchar; + +beginchar(141,541*FX#,331*FY#,0*FY#); +"asciitilde"; +dr +ah((520,329) +lt(542,329) +ct(541,287,529,254,506,230) +ct(483,206,455,194,422,194) +ct(407,194,391,196,374,201) +ct(357,206,312,224,240,253) +ct(190,273,154,284,133,284) +ct(111,284,91,277,76,263) +ct(60,249,49,226,42,195) +lt(21,195) +ct(23,239,35,272,57,296) +ct(79,319,105,331,135,331) +ct(149,331,164,328,179,324) +ct(213,314,258,297,313,274) +ct(368,250,407,238,429,238) +ct(454,238,474,246,491,262) +ct(507,277,517,300,520,329) + )cp +endchar; + +beginchar(142,350*FX#,453*FY#,0*FY#); +"bullet"; +dr +ah((177,453) +ct(211,453,239,441,263,417) +ct(287,393,299,364,299,330) +ct(299,296,287,267,263,243) +ct(239,219,211,208,177,208) +ct(143,208,114,219,90,243) +ct(66,267,54,296,54,330) +ct(54,364,66,393,90,417) +ct(114,441,143,453,177,453) + )cp +endchar; + +beginchar(159,1*FX#,0*FY#,0*FY#); +"fraction"; +endchar; + +beginchar(12,1*FX#,0*FY#,0*FY#); +"fi"; +endchar; + +beginchar(13,1*FX#,0*FY#,0*FY#); +"fl"; +endchar; + +beginchar(150,1*FX#,0*FY#,0*FY#); +"Lslash"; +endchar; + +beginchar(151,1*FX#,0*FY#,0*FY#); +"lslash"; +endchar; + +beginchar(208,722*FX#,662*FY#,0*FY#); +"Eth"; +dr +ah((17,0) +lt(17,18) +lt(41,18) +ct(69,18,89,27,102,45) +ct(108,55,112,79,112,117) +lt(112,331) +lt(17,331) +lt(17,367) +lt(112,367) +lt(112,544) +ct(112,585,107,611,98,622) +ct(85,636,66,644,41,644) +lt(17,644) +lt(17,662) +lt(286,662) +ct(389,662,465,650,514,627) +ct(563,603,603,566,635,515) +ct(667,464,683,404,683,335) +ct(683,242,653,162,593,97) +ct(534,32,440,0,312,0) +lt(17,0) + )cp +dr +ah((206,48) +ct(247,39,282,35,310,35) +ct(385,35,448,61,498,114) +ct(547,167,572,239,572,330) +ct(572,422,547,494,498,546) +ct(448,599,384,625,306,625) +ct(276,625,243,620,206,611) +lt(206,367) +lt(398,367) +lt(398,331) +lt(206,331) +lt(206,48) + )cp +endchar; + +beginchar(240,500*FX#,694*FY#,13*FY#); +"eth"; +dr +ah((229,570) +lt(108,504) +lt(93,531) +lt(207,596) +ct(186,618,169,633,158,642) +ct(148,651,133,661,115,673) +lt(128,694) +ct(167,674,207,649,249,618) +lt(371,686) +lt(387,659) +lt(275,596) +ct(337,542,384,483,416,418) +ct(447,354,463,291,463,231) +ct(463,186,454,144,435,106) +ct(416,68,390,39,356,18) +ct(322,-3,284,-13,243,-13) +ct(185,-13,135,8,94,51) +ct(53,94,33,149,33,215) +ct(33,283,55,343,100,393) +ct(138,435,184,456,238,456) +ct(254,456,268,454,281,450) +ct(291,446,304,439,320,427) +ct(294,481,263,528,229,570) + )cp +dr +ah((233,426) +ct(202,426,176,413,155,387) +ct(134,360,123,316,123,252) +ct(123,208,130,167,143,130) +ct(156,93,174,65,196,47) +ct(219,29,242,20,267,20) +ct(296,20,321,33,342,59) +ct(362,84,373,126,373,184) +ct(373,257,360,316,334,360) +ct(308,404,275,426,233,426) + )cp +endchar; + +beginchar(222,556*FX#,662*FY#,0*FY#); +"Thorn"; +dr +ah((205,511) +lt(241,511) +ct(289,511,326,509,350,505) +ct(385,499,414,489,438,474) +ct(461,459,480,439,495,415) +ct(510,390,517,362,517,332) +ct(517,306,512,283,503,262) +ct(493,241,481,222,465,207) +ct(449,192,431,180,411,170) +ct(390,161,364,155,332,150) +ct(320,148,289,148,239,148) +lt(205,148) +lt(205,118) +ct(205,76,210,49,221,36) +ct(233,24,252,18,279,18) +lt(299,18) +lt(299,0) +lt(17,0) +lt(17,18) +lt(36,18) +ct(66,18,87,27,101,45) +ct(107,54,110,78,110,117) +lt(110,541) +ct(110,578,109,600,105,609) +ct(101,618,93,626,81,633) +ct(69,640,54,644,37,644) +lt(17,644) +lt(17,662) +lt(299,662) +lt(299,644) +lt(280,644) +ct(265,644,250,640,234,632) +ct(224,628,217,620,212,608) +ct(207,597,205,575,205,543) +lt(205,511) + )cp +dr +ah((205,473) +lt(205,183) +lt(226,183) +ct(266,183,297,187,319,196) +ct(348,209,370,226,384,250) +ct(398,273,405,299,405,330) +ct(405,354,400,377,390,397) +ct(380,418,366,434,350,446) +ct(333,457,315,465,295,469) +ct(281,471,259,473,228,473) +lt(205,473) + )cp +endchar; + +beginchar(254,500*FX#,694*FY#,213*FY#); +"thorn"; +dr +ah((0,638) +lt(136,694) +lt(155,694) +lt(155,354) +ct(178,393,201,420,224,436) +ct(248,452,272,460,298,460) +ct(342,460,380,442,410,407) +ct(446,364,465,308,465,239) +ct(465,162,443,98,399,48) +ct(362,7,316,-13,261,-13) +ct(237,-13,216,-9,199,-3) +ct(185,1,171,10,155,25) +lt(155,-110) +ct(155,-140,157,-159,160,-167) +ct(164,-176,171,-182,180,-187) +ct(189,-192,206,-194,230,-194) +lt(230,-213) +lt(-3,-213) +lt(-3,-194) +lt(8,-195) +ct(26,-195,41,-191,54,-185) +ct(60,-181,65,-175,69,-167) +ct(72,-159,74,-139,74,-107) +lt(74,551) +ct(74,580,72,598,70,606) +ct(67,614,63,620,57,624) +ct(52,628,44,630,34,630) +ct(26,630,16,627,4,623) +lt(0,638) + )cp +dr +ah((155,325) +lt(155,158) +ct(155,122,156,98,159,86) +ct(164,68,175,51,193,37) +ct(210,22,233,15,260,15) +ct(292,15,319,27,339,53) +ct(365,86,378,133,378,193) +ct(378,261,363,314,333,351) +ct(312,376,287,389,259,389) +ct(243,389,228,385,213,377) +ct(201,371,181,354,155,325) + )cp +endchar; + +beginchar(181,576*FX#,447*FY#,215*FY#); +"mu"; +dr +ah((95,447) +lt(175,447) +lt(175,187) +ct(175,139,178,107,184,90) +ct(188,77,196,66,208,58) +ct(219,50,231,46,245,46) +ct(283,46,321,67,360,111) +lt(360,447) +lt(440,447) +lt(440,127) +ct(440,95,441,73,444,63) +ct(447,56,451,50,456,45) +ct(462,41,467,39,474,39) +ct(482,39,489,42,495,49) +ct(503,59,509,75,513,99) +lt(534,99) +ct(531,60,520,31,503,13) +ct(485,-4,463,-13,437,-13) +ct(411,-13,392,-4,378,14) +ct(368,28,362,49,360,79) +ct(332,45,305,22,281,7) +ct(256,-6,232,-13,207,-13) +ct(189,-13,174,-9,162,-3) +ct(152,1,142,11,131,27) +ct(130,17,130,9,130,5) +ct(130,-20,135,-59,147,-111) +ct(151,-131,153,-148,153,-162) +ct(153,-177,149,-190,140,-200) +ct(131,-210,120,-215,107,-215) +ct(95,-215,85,-211,77,-201) +ct(69,-192,65,-179,65,-162) +ct(65,-147,69,-120,79,-82) +ct(85,-55,89,-38,90,-31) +ct(94,2,96,31,96,56) +ct(96,57,95,69,95,92) +lt(95,447) + )cp +endchar; + +beginchar(177,548*FX#,595*FY#,0*FY#); +"plusminus"; +dr +ah((11,68) +lt(11,108) +lt(254,108) +lt(254,312) +lt(11,312) +lt(11,352) +lt(254,352) +lt(254,595) +lt(293,595) +lt(293,352) +lt(537,352) +lt(537,312) +lt(293,312) +lt(293,108) +lt(538,108) +lt(537,68) +lt(11,68) + )cp +endchar; + +beginchar(189,750*FX#,675*FY#,26*FY#); +"onehalf"; +dr +ah((65,633) +lt(165,675) +lt(182,675) +lt(182,386) +ct(182,366,183,354,185,350) +ct(186,347,189,345,193,343) +ct(198,340,211,339,231,339) +lt(231,324) +lt(73,324) +lt(73,339) +ct(93,339,106,340,112,343) +ct(116,344,118,347,120,351) +ct(122,354,123,366,123,386) +lt(123,569) +ct(123,592,122,607,120,615) +ct(119,620,117,624,115,626) +ct(113,628,109,629,105,629) +ct(99,629,88,625,73,619) +lt(65,633) + )cp +dr +ah((619,675) +lt(162,-26) +lt(119,-26) +lt(575,675) +lt(619,675) + )cp +dr +ah((729,55) +lt(699,-19) +lt(458,-19) +lt(458,-4) +ct(538,57,592,107,618,147) +ct(634,171,643,195,643,217) +ct(643,237,636,254,622,267) +ct(609,281,592,288,571,288) +ct(553,288,536,283,522,273) +ct(508,264,498,249,491,230) +lt(469,230) +ct(473,262,486,286,507,305) +ct(527,323,554,332,587,332) +ct(621,332,649,322,671,303) +ct(693,284,704,263,704,240) +ct(704,218,696,195,680,171) +ct(656,133,608,85,536,27) +lt(627,27) +ct(655,27,674,29,683,33) +ct(693,37,701,44,707,55) +lt(729,55) + )cp +endchar; + +beginchar(127,333*FX#,652*FY#,0*FY#); +"dieresis"; +dr +ah((252,652) +ct(267,652,280,647,290,637) +ct(300,626,305,614,305,599) +ct(305,584,300,572,290,562) +ct(280,552,267,546,252,546) +ct(238,546,225,552,215,562) +ct(204,572,199,584,199,599) +ct(199,614,204,626,215,637) +ct(225,647,238,652,252,652) + )cp +dr +ah((80,652) +ct(95,652,108,647,118,637) +ct(128,626,133,614,133,599) +ct(133,584,128,572,118,562) +ct(107,552,95,546,81,546) +ct(66,546,53,552,43,562) +ct(33,572,27,584,27,599) +ct(27,614,32,626,43,637) +ct(53,647,65,652,80,652) + )cp +chp[200]:=currentpicture; +endchar; + +beginchar(39,333*FX#,677*FY#,0*FY#); +"quoteright"; +dr +ah((116,424) +lt(116,447) +ct(149,467,172,485,184,502) +ct(192,514,197,529,197,547) +ct(197,557,195,564,191,569) +ct(187,574,183,577,179,577) +ct(175,577,170,575,165,573) +ct(156,570,149,569,144,569) +ct(131,569,119,574,109,583) +ct(99,593,94,605,94,620) +ct(94,636,99,649,109,658) +ct(122,670,138,677,158,677) +ct(180,677,199,668,217,649) +ct(234,631,243,608,243,581) +ct(243,542,228,507,199,476) +ct(179,454,152,437,116,424) + )cp +endchar; + +beginchar(183,1*FX#,0*FY#,0*FY#); +"periodcentered"; +endchar; + +beginchar(126,333*FX#,676*FY#,0*FY#); +"tilde"; +dr +ah((121,676) +lt(211,676) +lt(304,514) +lt(289,514) +lt(155,618) +lt(43,514) +lt(29,514) +lt(121,676) + )cp +chp[196]:=currentpicture; +endchar; + +beginchar(94,333*FX#,662*FY#,0*FY#); +"circumflex"; +dr +ah((26,535) +lt(10,535) +ct(12,580,21,612,38,632) +ct(55,652,77,662,102,662) +ct(115,662,127,659,139,655) +ct(153,650,174,638,201,620) +ct(228,603,248,594,261,594) +ct(271,594,280,598,288,607) +ct(296,616,303,634,307,662) +lt(322,662) +ct(323,631,319,607,310,590) +ct(302,572,290,558,275,548) +ct(260,538,245,533,229,533) +ct(203,533,172,546,134,572) +ct(113,586,99,595,92,598) +ct(85,601,78,602,71,602) +ct(57,602,47,596,40,584) +ct(36,578,31,562,26,535) + )cp +chp[195]:=currentpicture; +endchar; + +beginchar(123,500*FX#,256*FY#,0*FY#); +"endash"; +dr +ah((508,221) +lt(-8,221) +lt(-8,256) +lt(508,256) +lt(508,221) + )cp +endchar; + +beginchar(19,333*FX#,678*FY#,0*FY#); +"acute"; +dr +ah((275,678) +lt(131,510) +lt(115,510) +lt(166,678) +lt(275,678) + )cp +chp[194]:=currentpicture; +endchar; + +beginchar(22,1*FX#,0*FY#,0*FY#); +"macron"; +endchar; + +beginchar(96,333*FX#,677*FY#,0*FY#); +"quoteleft"; +dr +ah((216,677) +lt(216,656) +ct(182,635,160,616,148,600) +ct(139,587,135,572,135,555) +ct(135,544,137,536,141,532) +ct(144,526,148,524,154,524) +ct(157,524,161,525,167,528) +ct(176,530,183,532,189,532) +ct(202,532,214,527,224,518) +ct(234,508,239,496,239,481) +ct(239,464,234,451,224,442) +ct(210,430,193,424,175,424) +ct(153,424,133,433,116,452) +ct(98,470,90,493,90,520) +ct(90,558,104,593,133,625) +ct(152,646,180,663,216,677) + )cp +endchar; + +beginchar(23,333*FX#,695*FY#,0*FY#); +"ring"; +dr +ah((166,695) +ct(192,695,214,686,232,667) +ct(251,649,260,627,260,602) +ct(260,576,251,553,232,535) +ct(214,517,192,508,166,508) +ct(140,508,118,517,100,535) +ct(82,553,73,576,73,602) +ct(73,627,82,649,100,667) +ct(118,686,140,695,166,695) + )cp +dr +ah((166,661) +ct(149,661,135,655,124,644) +ct(112,632,106,618,106,602) +ct(106,585,112,571,124,560) +ct(135,548,149,542,166,542) +ct(183,542,197,548,208,560) +ct(220,571,226,585,226,602) +ct(226,618,220,632,208,644) +ct(197,655,183,661,166,661) + )cp +chp[202]:=currentpicture; +endchar; + +beginchar(95,1*FX#,0*FY#,0*FY#); +"dotaccent"; +endchar; + +beginchar(125,1*FX#,0*FY#,0*FY#); +"hungarumlaut"; +endchar; + +beginchar(24,333*FX#,7*FY#,190*FY#); +"cedilla"; +dr +ah((176,7) +lt(205,7) +lt(181,-30) +ct(201,-35,216,-44,227,-57) +ct(237,-69,242,-84,242,-102) +ct(242,-125,232,-146,212,-163) +ct(193,-181,168,-190,137,-190) +ct(125,-190,109,-189,91,-187) +lt(91,-166) +ct(99,-166,107,-167,114,-167) +ct(131,-167,145,-162,156,-151) +ct(168,-140,173,-128,173,-114) +ct(173,-104,170,-96,162,-88) +ct(155,-81,145,-78,134,-78) +ct(130,-78,126,-78,122,-79) +lt(176,7) + )cp +chp[203]:=currentpicture; +endchar; + +beginchar(158,1*FX#,0*FY#,0*FY#); +"ogonek"; +endchar; + +beginchar(20,333*FX#,676*FY#,0*FY#); +"caron"; +dr +ah((211,514) +lt(122,514) +lt(29,676) +lt(44,676) +lt(177,572) +lt(289,676) +lt(304,676) +lt(211,514) + )cp +chp[207]:=currentpicture; +endchar; + +beginchar(21,1*FX#,0*FY#,0*FY#); +"breve"; +endchar; + +beginchar(16,277*FX#,460*FY#,0*FY#); +"dotlessi"; +dr +ah((185,460) +lt(185,101) +ct(185,73,187,54,191,45) +ct(195,35,201,28,209,24) +ct(217,19,232,17,253,17) +lt(253,0) +lt(36,0) +lt(36,17) +ct(57,17,72,19,80,23) +ct(87,28,93,35,97,44) +ct(102,54,104,73,104,101) +lt(104,273) +ct(104,321,102,353,100,367) +ct(97,378,94,385,89,389) +ct(84,393,77,395,69,395) +ct(59,395,48,392,36,388) +lt(29,405) +lt(164,460) +lt(185,460) + )cp +chp[245]:=currentpicture; +endchar; + +beginchar(144,443*FX#,97*FY#,154*FY#); +"quotedblbase"; +dr +ah((56,-154) +lt(56,-133) +ct(89,-115,110,-98,120,-83) +ct(131,-68,136,-50,136,-30) +ct(136,-21,134,-14,131,-10) +ct(127,-5,123,-3,119,-3) +ct(115,-3,110,-4,104,-7) +ct(96,-9,89,-11,82,-11) +ct(68,-11,57,-6,47,3) +ct(37,13,32,25,32,39) +ct(32,54,38,68,51,80) +ct(64,91,79,97,97,97) +ct(118,97,138,88,155,69) +ct(172,51,181,27,181,0) +ct(181,-34,170,-65,148,-94) +ct(126,-122,95,-142,56,-154) + )cp +dr +ah((289,-154) +lt(289,-133) +ct(317,-119,337,-103,350,-87) +ct(362,-70,369,-52,369,-33) +ct(369,-21,367,-13,364,-9) +ct(360,-5,357,-3,353,-3) +ct(349,-3,343,-4,336,-7) +ct(328,-9,322,-11,316,-11) +ct(303,-11,291,-6,281,3) +ct(272,13,267,26,267,40) +ct(267,55,273,69,285,80) +ct(297,91,312,97,329,97) +ct(351,97,371,88,389,69) +ct(406,50,415,26,415,0) +ct(415,-33,404,-63,383,-92) +ct(361,-120,330,-140,289,-154) + )cp +endchar; + +beginchar(192,722*FX#,877*FY#,0*FY#); +"Agrave"; +dr +ah((456,221) +lt(200,221) +lt(155,117) +ct(143,91,138,71,138,59) +ct(138,49,143,40,153,32) +ct(162,25,183,20,215,18) +lt(215,0) +lt(6,0) +lt(6,18) +ct(34,22,52,29,60,37) +ct(76,52,95,84,115,132) +lt(348,677) +lt(365,677) +lt(596,126) +ct(614,82,631,53,646,40) +ct(661,27,682,19,709,18) +lt(709,0) +lt(448,0) +lt(448,18) +ct(475,19,492,23,502,31) +ct(511,38,516,47,516,58) +ct(516,72,509,95,496,126) +lt(456,221) + )cp +dr +ah((442,257) +lt(330,525) +lt(215,257) +lt(442,257) + )cp +dr +ah((250,877) +lt(359,877) +lt(411,708) +lt(394,708) +lt(250,877) + )cp +endchar; + +beginchar(194,722*FX#,875*FY#,0*FY#); +"Acircumflex"; +dr +ah((456,221) +lt(200,221) +lt(155,117) +ct(143,91,138,71,138,59) +ct(138,49,143,40,153,32) +ct(162,25,183,20,215,18) +lt(215,0) +lt(6,0) +lt(6,18) +ct(34,22,52,29,60,37) +ct(76,52,95,84,115,132) +lt(348,677) +lt(365,677) +lt(596,126) +ct(614,82,631,53,646,40) +ct(661,27,682,19,709,18) +lt(709,0) +lt(448,0) +lt(448,18) +ct(475,19,492,23,502,31) +ct(511,38,516,47,516,58) +ct(516,72,509,95,496,126) +lt(456,221) + )cp +dr +ah((442,257) +lt(330,525) +lt(215,257) +lt(442,257) + )cp +dr +ah((313,875) +lt(403,875) +lt(496,713) +lt(481,713) +lt(348,817) +lt(236,713) +lt(221,713) +lt(313,875) + )cp +endchar; + +beginchar(200,610*FX#,877*FY#,0*FY#); +"Egrave"; +dr +ah((208,625) +lt(208,364) +lt(354,364) +ct(392,364,417,369,430,381) +ct(446,395,456,422,458,460) +lt(476,460) +lt(476,229) +lt(458,229) +ct(453,261,448,282,444,291) +ct(438,303,429,312,416,318) +ct(402,325,382,328,354,328) +lt(208,328) +lt(208,110) +ct(208,81,210,63,212,56) +ct(215,50,220,45,226,41) +ct(233,38,245,36,263,36) +lt(375,36) +ct(413,36,440,38,457,43) +ct(474,49,490,59,506,74) +ct(526,94,546,124,568,166) +lt(587,166) +lt(530,0) +lt(20,0) +lt(20,18) +lt(43,18) +ct(59,18,74,21,88,29) +ct(98,34,105,42,109,52) +ct(113,63,115,84,115,116) +lt(115,546) +ct(115,588,110,614,102,624) +ct(90,637,70,644,43,644) +lt(20,644) +lt(20,662) +lt(530,662) +lt(538,517) +lt(519,517) +ct(512,551,504,575,496,588) +ct(488,601,475,611,459,618) +ct(445,622,422,625,390,625) +lt(208,625) + )cp +dr +ah((198,877) +lt(307,877) +lt(358,708) +lt(341,708) +lt(198,877) + )cp +endchar; + +beginchar(202,610*FX#,875*FY#,0*FY#); +"Ecircumflex"; +dr +ah((208,625) +lt(208,364) +lt(354,364) +ct(392,364,417,369,430,381) +ct(446,395,456,422,458,460) +lt(476,460) +lt(476,229) +lt(458,229) +ct(453,261,448,282,444,291) +ct(438,303,429,312,416,318) +ct(402,325,382,328,354,328) +lt(208,328) +lt(208,110) +ct(208,81,210,63,212,56) +ct(215,50,220,45,226,41) +ct(233,38,245,36,263,36) +lt(375,36) +ct(413,36,440,38,457,43) +ct(474,49,490,59,506,74) +ct(526,94,546,124,568,166) +lt(587,166) +lt(530,0) +lt(20,0) +lt(20,18) +lt(43,18) +ct(59,18,74,21,88,29) +ct(98,34,105,42,109,52) +ct(113,63,115,84,115,116) +lt(115,546) +ct(115,588,110,614,102,624) +ct(90,637,70,644,43,644) +lt(20,644) +lt(20,662) +lt(530,662) +lt(538,517) +lt(519,517) +ct(512,551,504,575,496,588) +ct(488,601,475,611,459,618) +ct(445,622,422,625,390,625) +lt(208,625) + )cp +dr +ah((262,875) +lt(352,875) +lt(444,713) +lt(429,713) +lt(296,817) +lt(184,713) +lt(169,713) +lt(262,875) + )cp +endchar; + +beginchar(203,610*FX#,833*FY#,0*FY#); +"Edieresis"; +dr +ah((208,625) +lt(208,364) +lt(354,364) +ct(392,364,417,369,430,381) +ct(446,395,456,422,458,460) +lt(476,460) +lt(476,229) +lt(458,229) +ct(453,261,448,282,444,291) +ct(438,303,429,312,416,318) +ct(402,325,382,328,354,328) +lt(208,328) +lt(208,110) +ct(208,81,210,63,212,56) +ct(215,50,220,45,226,41) +ct(233,38,245,36,263,36) +lt(375,36) +ct(413,36,440,38,457,43) +ct(474,49,490,59,506,74) +ct(526,94,546,124,568,166) +lt(587,166) +lt(530,0) +lt(20,0) +lt(20,18) +lt(43,18) +ct(59,18,74,21,88,29) +ct(98,34,105,42,109,52) +ct(113,63,115,84,115,116) +lt(115,546) +ct(115,588,110,614,102,624) +ct(90,637,70,644,43,644) +lt(20,644) +lt(20,662) +lt(530,662) +lt(538,517) +lt(519,517) +ct(512,551,504,575,496,588) +ct(488,601,475,611,459,618) +ct(445,622,422,625,390,625) +lt(208,625) + )cp +dr +ah((393,833) +ct(407,833,420,828,430,818) +ct(440,807,445,795,445,780) +ct(445,766,440,753,430,743) +ct(420,733,407,728,393,728) +ct(378,728,365,733,355,743) +ct(345,753,339,766,339,780) +ct(339,795,345,807,355,818) +ct(365,828,378,833,393,833) + )cp +dr +ah((220,833) +ct(235,833,248,828,258,818) +ct(268,807,273,795,273,780) +ct(273,766,268,753,258,743) +ct(247,733,235,728,221,728) +ct(206,728,194,733,183,743) +ct(173,753,167,766,167,780) +ct(167,795,173,807,183,818) +ct(193,828,206,833,220,833) + )cp +endchar; + +beginchar(206,333*FX#,875*FY#,0*FY#); +"Icircumflex"; +dr +ah((308,18) +lt(308,0) +lt(24,0) +lt(24,18) +lt(48,18) +ct(75,18,95,25,107,41) +ct(115,51,119,77,119,117) +lt(119,544) +ct(119,578,117,600,113,611) +ct(109,619,103,626,93,632) +ct(78,640,63,644,48,644) +lt(24,644) +lt(24,662) +lt(308,662) +lt(308,644) +lt(284,644) +ct(257,644,237,636,225,620) +ct(217,609,213,584,213,544) +lt(213,117) +ct(213,83,215,60,219,50) +ct(222,42,229,35,240,29) +ct(254,21,268,18,284,18) +lt(308,18) + )cp +dr +ah((121,875) +lt(211,875) +lt(304,713) +lt(289,713) +lt(155,817) +lt(43,713) +lt(29,713) +lt(121,875) + )cp +endchar; + +beginchar(207,333*FX#,833*FY#,0*FY#); +"Idieresis"; +dr +ah((308,18) +lt(308,0) +lt(24,0) +lt(24,18) +lt(48,18) +ct(75,18,95,25,107,41) +ct(115,51,119,77,119,117) +lt(119,544) +ct(119,578,117,600,113,611) +ct(109,619,103,626,93,632) +ct(78,640,63,644,48,644) +lt(24,644) +lt(24,662) +lt(308,662) +lt(308,644) +lt(284,644) +ct(257,644,237,636,225,620) +ct(217,609,213,584,213,544) +lt(213,117) +ct(213,83,215,60,219,50) +ct(222,42,229,35,240,29) +ct(254,21,268,18,284,18) +lt(308,18) + )cp +dr +ah((252,833) +ct(267,833,279,828,289,818) +ct(300,807,305,795,305,780) +ct(305,766,300,753,289,743) +ct(279,733,267,728,252,728) +ct(237,728,225,733,214,743) +ct(204,753,199,766,199,780) +ct(199,795,204,807,214,818) +ct(225,828,237,833,252,833) + )cp +dr +ah((80,833) +ct(95,833,107,828,117,818) +ct(128,807,133,795,133,780) +ct(133,766,128,753,117,743) +ct(107,733,94,728,80,728) +ct(65,728,53,733,42,743) +ct(32,753,27,766,27,780) +ct(27,795,32,807,42,818) +ct(52,828,65,833,80,833) + )cp +endchar; + +beginchar(169,759*FX#,677*FY#,15*FY#); +"copyright"; +dr +ah((379,677) +ct(438,677,494,662,550,632) +ct(605,602,648,560,679,504) +ct(711,449,726,391,726,331) +ct(726,271,711,213,680,158) +ct(650,103,607,60,552,30) +ct(497,0,439,-15,379,-15) +ct(319,-15,262,0,207,30) +ct(152,60,110,103,79,158) +ct(48,213,33,271,33,331) +ct(33,391,49,449,80,504) +ct(111,560,154,602,209,632) +ct(265,662,321,677,379,677) + )cp +dr +ah((379,647) +ct(326,647,275,633,224,606) +ct(174,579,134,540,106,489) +ct(78,438,63,386,63,331) +ct(63,276,77,223,105,173) +ct(133,123,172,84,222,56) +ct(272,28,325,14,379,14) +ct(434,14,487,28,537,56) +ct(587,84,626,123,654,173) +ct(682,223,696,276,696,331) +ct(696,386,682,438,653,489) +ct(625,540,586,579,535,606) +ct(485,633,433,647,379,647) + )cp +dr +ah((551,553) +lt(561,416) +lt(541,416) +ct(530,455,511,484,486,503) +ct(460,522,429,532,394,532) +ct(367,532,343,526,322,515) +ct(301,504,284,489,271,471) +ct(261,457,253,438,247,415) +ct(240,392,237,368,237,342) +ct(237,273,252,222,281,189) +ct(311,156,350,140,398,140) +ct(462,140,513,166,551,219) +lt(569,210) +ct(523,144,461,111,382,111) +ct(317,111,263,132,220,174) +ct(177,216,156,267,156,328) +ct(156,390,179,443,224,488) +ct(270,532,328,554,399,554) +ct(414,554,426,553,436,551) +ct(446,549,464,544,489,535) +ct(497,532,503,531,507,531) +ct(513,531,517,533,520,535) +ct(524,538,528,544,531,553) +lt(551,553) + )cp +endchar; + +beginchar(174,759*FX#,677*FY#,15*FY#); +"registered"; +dr +ah((379,677) +ct(438,677,494,662,550,632) +ct(605,602,648,560,679,504) +ct(711,449,726,391,726,331) +ct(726,271,711,213,680,158) +ct(650,103,607,60,552,30) +ct(497,0,439,-15,379,-15) +ct(319,-15,262,0,207,30) +ct(152,60,110,103,79,158) +ct(48,213,33,271,33,331) +ct(33,391,49,449,80,504) +ct(111,560,154,602,209,632) +ct(265,662,321,677,379,677) + )cp +dr +ah((379,647) +ct(326,647,275,633,224,606) +ct(174,579,134,540,106,489) +ct(78,438,63,386,63,331) +ct(63,276,77,223,105,173) +ct(133,123,172,84,222,56) +ct(272,28,325,14,379,14) +ct(434,14,487,28,537,56) +ct(587,84,626,123,654,173) +ct(682,223,696,276,696,331) +ct(696,386,682,438,653,489) +ct(625,540,586,579,535,606) +ct(485,633,433,647,379,647) + )cp +dr +ah((188,543) +lt(376,543) +ct(424,543,460,533,484,511) +ct(509,490,521,464,521,434) +ct(521,409,513,388,496,369) +ct(480,350,452,336,413,326) +lt(515,180) +ct(527,162,538,151,548,145) +ct(554,141,563,138,574,137) +lt(574,121) +lt(484,121) +lt(341,319) +lt(304,319) +lt(304,168) +ct(306,157,310,149,318,145) +ct(325,140,340,137,361,137) +lt(361,121) +lt(182,121) +lt(182,137) +ct(198,137,209,139,215,143) +ct(222,147,227,152,229,159) +ct(231,164,233,179,233,205) +lt(233,460) +ct(233,484,232,498,231,502) +ct(229,510,225,516,219,520) +ct(213,524,203,526,188,526) +lt(188,543) + )cp +dr +ah((304,340) +ct(342,340,370,344,388,351) +ct(406,359,419,369,429,383) +ct(438,396,443,411,443,429) +ct(443,455,434,477,415,495) +ct(397,513,373,522,345,522) +ct(332,522,318,519,304,514) +lt(304,340) + )cp +endchar; + +beginchar(147,979*FX#,662*FY#,0*FY#); +"trademark"; +dr +ah((24,662) +lt(380,662) +lt(391,563) +lt(374,563) +ct(371,587,362,604,348,615) +ct(335,627,312,632,279,632) +lt(243,632) +lt(243,350) +ct(243,322,246,305,252,298) +ct(259,290,273,286,294,285) +lt(294,268) +lt(112,268) +lt(112,285) +ct(133,287,146,292,152,299) +ct(158,306,161,322,161,349) +lt(161,632) +lt(124,632) +ct(93,632,71,627,58,617) +ct(45,607,36,589,31,563) +lt(14,563) +lt(24,662) + )cp +dr +ah((564,662) +lt(697,382) +lt(827,662) +lt(963,662) +lt(963,644) +ct(945,643,933,641,927,638) +ct(920,635,916,630,913,623) +ct(910,615,909,600,909,578) +lt(909,349) +ct(909,321,912,304,918,297) +ct(924,291,939,286,963,285) +lt(963,268) +lt(769,268) +lt(769,285) +ct(788,285,801,287,807,291) +ct(814,295,819,300,822,307) +ct(825,313,827,327,827,349) +lt(827,589) +lt(677,268) +lt(661,268) +lt(511,584) +lt(511,349) +ct(511,327,512,313,515,306) +ct(518,299,522,294,528,291) +ct(534,287,543,285,556,285) +lt(574,285) +lt(574,268) +lt(424,268) +lt(424,285) +ct(443,285,455,287,461,290) +ct(468,293,472,298,475,305) +ct(478,312,479,327,479,349) +lt(479,577) +ct(479,601,478,617,475,624) +ct(473,630,468,635,461,638) +ct(455,642,443,644,424,644) +lt(424,662) +lt(564,662) + )cp +endchar; + +beginchar(135,333*FX#,456*FY#,3*FY#); +"guilsinglleft"; +dr +ah((274,-3) +lt(247,-3) +lt(58,226) +lt(247,456) +lt(274,456) +lt(155,226) +lt(274,-3) + )cp +endchar; + +beginchar(136,333*FX#,456*FY#,3*FY#); +"guilsinglright"; +dr +ah((56,456) +lt(84,456) +lt(276,225) +lt(84,-3) +lt(56,-3) +lt(174,225) +lt(56,456) + )cp +endchar; + +beginchar(217,722*FX#,877*FY#,15*FY#); +"Ugrave"; +dr +ah((477,644) +lt(477,662) +lt(711,662) +lt(711,644) +lt(686,644) +ct(660,644,640,633,626,611) +ct(619,601,616,577,616,541) +lt(616,272) +ct(616,206,609,154,596,117) +ct(583,81,557,49,518,23) +ct(480,-2,427,-15,361,-15) +ct(289,-15,234,-3,196,21) +ct(159,47,132,80,117,123) +ct(106,151,101,206,101,286) +lt(101,544) +ct(101,585,95,612,84,625) +ct(73,637,55,644,30,644) +lt(5,644) +lt(5,662) +lt(291,662) +lt(291,644) +lt(266,644) +ct(238,644,219,635,207,618) +ct(199,606,195,581,195,544) +lt(195,256) +ct(195,230,197,201,202,167) +ct(207,134,215,108,228,90) +ct(240,71,258,56,281,44) +ct(304,32,333,26,367,26) +ct(410,26,449,35,483,54) +ct(517,73,540,97,553,127) +ct(565,156,572,206,572,276) +lt(572,544) +ct(572,585,567,611,558,622) +ct(545,636,526,644,501,644) +lt(477,644) + )cp +dr +ah((274,877) +lt(383,877) +lt(435,708) +lt(417,708) +lt(274,877) + )cp +endchar; + +beginchar(219,722*FX#,875*FY#,15*FY#); +"Ucircumflex"; +dr +ah((477,644) +lt(477,662) +lt(711,662) +lt(711,644) +lt(686,644) +ct(660,644,640,633,626,611) +ct(619,601,616,577,616,541) +lt(616,272) +ct(616,206,609,154,596,117) +ct(583,81,557,49,518,23) +ct(480,-2,427,-15,361,-15) +ct(289,-15,234,-3,196,21) +ct(159,47,132,80,117,123) +ct(106,151,101,206,101,286) +lt(101,544) +ct(101,585,95,612,84,625) +ct(73,637,55,644,30,644) +lt(5,644) +lt(5,662) +lt(291,662) +lt(291,644) +lt(266,644) +ct(238,644,219,635,207,618) +ct(199,606,195,581,195,544) +lt(195,256) +ct(195,230,197,201,202,167) +ct(207,134,215,108,228,90) +ct(240,71,258,56,281,44) +ct(304,32,333,26,367,26) +ct(410,26,449,35,483,54) +ct(517,73,540,97,553,127) +ct(565,156,572,206,572,276) +lt(572,544) +ct(572,585,567,611,558,622) +ct(545,636,526,644,501,644) +lt(477,644) + )cp +dr +ah((337,875) +lt(427,875) +lt(520,713) +lt(504,713) +lt(371,817) +lt(259,713) +lt(245,713) +lt(337,875) + )cp +endchar; + +beginchar(92,443*FX#,677*FY#,0*FY#); +"quotedblleft"; +dr +ah((159,677) +lt(159,657) +ct(130,642,110,626,97,610) +ct(85,594,79,576,79,557) +ct(79,545,80,537,83,533) +ct(86,528,90,526,94,526) +ct(98,526,104,528,111,530) +ct(118,532,125,534,131,534) +ct(144,534,156,529,166,519) +ct(176,509,181,497,181,482) +ct(181,467,175,453,163,442) +ct(151,431,136,425,118,425) +ct(96,425,76,435,59,454) +ct(41,472,32,496,32,523) +ct(32,556,43,586,65,614) +ct(86,643,118,663,159,677) + )cp +dr +ah((392,675) +lt(392,657) +ct(359,638,337,621,327,606) +ct(316,591,311,573,311,553) +ct(311,544,312,537,316,533) +ct(320,528,324,526,328,526) +ct(331,526,337,527,344,530) +ct(351,532,358,534,365,534) +ct(379,534,390,529,400,519) +ct(410,510,415,498,415,484) +ct(415,468,409,454,396,442) +ct(384,431,368,425,350,425) +ct(329,425,309,434,292,453) +ct(275,471,266,494,266,522) +ct(266,556,277,587,299,615) +ct(321,644,352,664,392,675) + )cp +endchar; + +beginchar(34,443*FX#,774*FY#,0*FY#); +"quotedblright"; +dr +ah((56,522) +lt(56,543) +ct(89,562,110,578,120,593) +ct(131,609,136,626,136,646) +ct(136,655,134,662,131,666) +ct(127,670,123,673,119,673) +ct(115,673,110,671,104,669) +ct(96,667,89,666,82,666) +ct(68,666,57,670,47,680) +ct(37,690,32,702,32,716) +ct(32,731,38,745,51,757) +ct(64,769,79,774,97,774) +ct(118,774,138,765,155,747) +ct(172,728,181,705,181,676) +ct(181,642,170,611,148,583) +ct(126,554,95,534,56,522) + )cp +dr +ah((289,522) +lt(289,543) +ct(317,558,337,573,350,590) +ct(362,606,369,624,369,643) +ct(369,654,367,662,364,667) +ct(360,671,357,673,353,673) +ct(349,673,343,671,336,669) +ct(328,667,322,666,316,666) +ct(303,666,291,671,281,681) +ct(272,691,267,703,267,717) +ct(267,732,273,746,285,757) +ct(297,769,312,774,329,774) +ct(351,774,371,765,389,746) +ct(406,727,415,703,415,676) +ct(415,643,404,613,383,585) +ct(361,557,330,536,289,522) + )cp +endchar; + +beginchar(176,399*FX#,676*FY#,0*FY#); +"degree"; +dr +ah((197,676) +ct(239,676,275,662,304,632) +ct(333,603,348,568,348,526) +ct(348,485,333,449,304,420) +ct(274,391,239,376,197,376) +ct(156,376,121,391,91,420) +ct(62,449,47,485,47,526) +ct(47,568,62,603,91,632) +ct(120,662,156,676,197,676) + )cp +dr +ah((197,635) +ct(167,635,141,625,120,604) +ct(99,582,88,557,88,526) +ct(88,496,99,471,120,449) +ct(141,428,167,417,197,417) +ct(227,417,253,428,274,449) +ct(295,471,306,496,306,526) +ct(306,557,296,582,274,604) +ct(253,625,228,635,197,635) + )cp +endchar; + +beginchar(199,666*FX#,677*FY#,190*FY#); +"Ccedilla"; +dr +ah((602,677) +lt(617,452) +lt(602,452) +ct(581,519,553,568,515,597) +ct(478,627,433,642,380,642) +ct(336,642,297,630,261,608) +ct(226,586,198,550,177,501) +ct(157,453,147,392,147,319) +ct(147,259,157,208,176,164) +ct(195,120,224,86,262,62) +ct(301,39,345,27,395,27) +ct(437,27,475,37,508,55) +ct(541,73,577,110,617,165) +lt(632,155) +ct(599,96,560,53,516,25) +ct(471,-1,419,-15,358,-15) +ct(248,-15,163,25,103,106) +ct(58,166,36,238,36,320) +ct(36,386,50,447,80,502) +ct(110,558,150,601,202,631) +ct(254,662,311,677,373,677) +ct(420,677,467,665,514,642) +ct(528,634,537,631,543,631) +ct(552,631,560,634,566,640) +ct(574,648,580,661,584,677) +lt(602,677) + )cp +dr +ah((340,7) +lt(370,7) +lt(345,-30) +ct(366,-35,381,-44,391,-57) +ct(401,-69,406,-84,406,-102) +ct(406,-125,396,-146,377,-163) +ct(357,-181,332,-190,301,-190) +ct(289,-190,273,-189,255,-187) +lt(255,-166) +ct(264,-166,272,-167,279,-167) +ct(295,-167,309,-162,321,-151) +ct(332,-140,338,-128,338,-114) +ct(338,-104,334,-96,327,-88) +ct(319,-81,310,-78,299,-78) +ct(295,-78,291,-78,286,-79) +lt(340,7) + )cp +endchar; + +beginchar(231,443*FX#,460*FY#,190*FY#); +"ccedilla"; +dr +ah((411,169) +ct(399,111,375,65,340,33) +ct(305,2,266,-13,223,-13) +ct(172,-13,128,7,90,50) +ct(53,92,34,150,34,223) +ct(34,293,55,350,96,394) +ct(138,438,188,460,247,460) +ct(291,460,327,448,355,425) +ct(384,402,398,378,398,353) +ct(398,340,394,330,386,322) +ct(378,315,367,311,353,311) +ct(333,311,319,317,309,330) +ct(304,336,300,349,298,369) +ct(296,388,290,402,278,413) +ct(266,422,251,427,231,427) +ct(198,427,172,415,152,391) +ct(126,359,113,317,113,265) +ct(113,211,126,164,152,123) +ct(178,82,214,62,258,62) +ct(290,62,318,73,344,95) +ct(362,109,379,136,396,176) +lt(411,169) + )cp +dr +ah((229,7) +lt(258,7) +lt(234,-30) +ct(254,-35,270,-44,280,-57) +ct(290,-69,295,-84,295,-102) +ct(295,-125,285,-146,266,-163) +ct(246,-181,221,-190,190,-190) +ct(178,-190,162,-189,144,-187) +lt(144,-166) +ct(153,-166,161,-167,167,-167) +ct(184,-167,198,-162,209,-151) +ct(221,-140,227,-128,227,-114) +ct(227,-104,223,-96,215,-88) +ct(208,-81,199,-78,187,-78) +ct(184,-78,180,-78,175,-79) +lt(229,7) + )cp +endchar; + +beginchar(209,722*FX#,841*FY#,10*FY#); +"Ntilde"; +dr +ah((-13,662) +lt(166,662) +lt(571,165) +lt(571,547) +ct(571,587,566,613,557,623) +ct(545,637,526,644,500,644) +lt(477,644) +lt(477,662) +lt(708,662) +lt(708,644) +lt(684,644) +ct(656,644,636,635,625,618) +ct(617,608,614,584,614,547) +lt(614,-10) +lt(596,-10) +lt(160,522) +lt(160,114) +ct(160,73,164,48,173,38) +ct(185,24,204,18,230,18) +lt(253,18) +lt(253,0) +lt(23,0) +lt(23,18) +lt(46,18) +ct(74,18,94,26,106,43) +ct(113,53,117,77,117,114) +lt(117,575) +ct(97,597,83,612,73,619) +ct(63,626,48,633,29,639) +ct(19,642,5,644,-13,644) +lt(-13,662) + )cp +dr +ah((218,715) +lt(203,715) +ct(204,759,213,792,230,812) +ct(248,831,269,841,294,841) +ct(307,841,319,839,331,835) +ct(346,829,366,818,393,800) +ct(420,782,440,773,453,773) +ct(464,773,473,778,481,787) +ct(489,795,495,814,500,841) +lt(515,841) +ct(515,811,511,787,503,769) +ct(494,752,483,738,468,728) +ct(452,718,437,713,422,713) +ct(396,713,364,726,326,752) +ct(306,766,292,774,285,777) +ct(277,780,270,782,264,782) +ct(250,782,240,776,232,764) +ct(228,758,224,742,218,715) + )cp +endchar; + +beginchar(241,500*FX#,662*FY#,0*FY#); +"ntilde"; +dr +ah((161,365) +ct(213,428,263,460,311,460) +ct(335,460,356,454,374,442) +ct(392,429,406,409,416,381) +ct(423,361,427,331,427,291) +lt(427,101) +ct(427,72,429,53,434,43) +ct(437,35,443,28,451,24) +ct(459,19,474,17,495,17) +lt(495,0) +lt(274,0) +lt(274,17) +lt(283,17) +ct(304,17,319,20,327,27) +ct(335,33,341,42,344,55) +ct(345,59,346,75,346,101) +lt(346,284) +ct(346,324,341,354,330,372) +ct(320,391,302,400,277,400) +ct(238,400,199,378,161,336) +lt(161,101) +ct(161,70,162,51,166,44) +ct(171,35,177,28,185,24) +ct(193,19,209,17,234,17) +lt(234,0) +lt(13,0) +lt(13,17) +lt(22,17) +ct(45,17,61,23,69,34) +ct(77,46,81,68,81,101) +lt(81,267) +ct(81,320,79,353,77,365) +ct(74,376,71,384,66,389) +ct(61,393,54,395,45,395) +ct(36,395,25,392,13,388) +lt(5,405) +lt(140,460) +lt(161,460) +lt(161,365) + )cp +dr +ah((109,535) +lt(94,535) +ct(95,580,104,612,122,632) +ct(139,652,160,662,186,662) +ct(199,662,211,659,222,655) +ct(237,650,258,638,284,620) +ct(311,603,331,594,344,594) +ct(355,594,364,598,372,607) +ct(380,616,386,634,391,662) +lt(406,662) +ct(406,631,402,607,394,590) +ct(385,572,374,558,359,548) +ct(343,538,328,533,313,533) +ct(287,533,255,546,217,572) +ct(197,586,183,595,176,598) +ct(169,601,162,602,155,602) +ct(141,602,131,596,123,584) +ct(119,578,115,562,109,535) + )cp +endchar; + +beginchar(60,333*FX#,475*FY#,215*FY#); +"exclamdown"; +dr +ah((166,475) +ct(182,475,195,470,205,459) +ct(215,449,221,436,221,421) +ct(221,406,215,393,205,383) +ct(194,372,181,367,166,367) +ct(152,367,139,372,128,383) +ct(118,393,113,406,113,421) +ct(113,436,118,449,128,459) +ct(139,470,152,475,166,475) + )cp +dr +ah((157,286) +lt(175,286) +lt(219,-108) +ct(220,-125,221,-138,221,-147) +ct(221,-167,216,-184,205,-197) +ct(194,-209,181,-215,166,-215) +ct(151,-215,138,-209,127,-197) +ct(116,-184,111,-166,111,-141) +ct(111,-133,111,-122,113,-108) +lt(157,286) + )cp +endchar; + +beginchar(62,443*FX#,476*FY#,215*FY#); +"questiondown"; +dr +ah((220,476) +ct(235,476,248,470,259,460) +ct(269,449,274,436,274,421) +ct(274,406,269,394,259,383) +ct(248,372,235,367,220,367) +ct(205,367,192,372,182,383) +ct(171,394,166,406,166,421) +ct(166,436,171,449,182,460) +ct(192,470,205,476,220,476) + )cp +dr +ah((215,305) +lt(234,305) +ct(232,265,228,233,222,209) +ct(216,186,199,145,172,89) +ct(145,32,132,-14,132,-51) +ct(132,-94,143,-127,164,-151) +ct(186,-174,213,-186,247,-186) +ct(275,-186,298,-179,314,-166) +ct(330,-153,338,-138,338,-122) +ct(338,-112,333,-98,323,-81) +ct(313,-63,308,-49,308,-39) +ct(308,-28,312,-19,320,-11) +ct(328,-3,337,0,348,0) +ct(361,0,373,-6,385,-20) +ct(396,-33,402,-51,402,-74) +ct(402,-111,386,-144,354,-173) +ct(322,-201,279,-215,224,-215) +ct(169,-215,125,-200,92,-170) +ct(59,-139,43,-103,43,-61) +ct(43,-33,47,-9,57,13) +ct(71,45,96,81,130,121) +ct(165,161,187,192,197,214) +ct(207,236,213,267,215,305) + )cp +endchar; + +beginchar(164,500*FX#,566*FY#,0*FY#); +"currency"; +dr +ah((387,497) +lt(457,566) +lt(485,539) +lt(415,470) +ct(448,426,465,381,465,333) +ct(465,282,448,236,415,194) +lt(485,123) +lt(457,96) +lt(387,166) +ct(343,132,299,116,255,116) +ct(227,116,199,121,172,131) +ct(144,141,124,152,111,166) +lt(40,96) +lt(13,123) +lt(83,194) +ct(49,232,33,278,33,332) +ct(33,382,49,428,83,470) +lt(13,539) +lt(40,566) +lt(111,497) +ct(128,512,150,524,176,533) +ct(202,542,227,547,250,547) +ct(273,547,297,543,322,534) +ct(346,526,368,513,387,497) + )cp +dr +ah((250,507) +ct(200,507,159,490,124,455) +ct(90,421,73,379,73,330) +ct(73,282,90,241,125,207) +ct(159,172,201,155,249,155) +ct(298,155,339,172,374,207) +ct(409,242,426,283,426,331) +ct(426,361,418,390,402,418) +ct(386,447,364,469,336,484) +ct(308,500,279,507,250,507) + )cp +endchar; + +beginchar(163,500*FX#,675*FY#,11*FY#); +"sterling"; +dr +ah((353,321) +lt(227,321) +ct(227,306,227,295,227,288) +ct(227,257,225,229,220,203) +ct(216,177,208,147,197,113) +ct(260,93,296,82,306,80) +ct(323,76,340,74,356,74) +ct(383,74,405,80,422,93) +ct(439,105,451,125,459,152) +lt(477,147) +ct(470,95,453,55,426,28) +ct(399,1,369,-11,336,-11) +ct(314,-11,294,-7,276,0) +ct(258,8,225,30,177,66) +ct(164,40,150,20,135,7) +ct(120,-5,104,-11,86,-11) +ct(70,-11,57,-6,46,5) +ct(35,16,29,31,29,51) +ct(29,73,37,91,52,105) +ct(67,120,86,127,109,127) +ct(115,127,121,127,128,126) +ct(135,125,142,124,151,123) +ct(152,131,152,139,152,145) +ct(152,151,152,156,152,161) +ct(152,189,148,243,142,321) +lt(47,321) +lt(47,368) +lt(142,368) +ct(138,416,136,448,136,465) +ct(136,505,144,541,160,574) +ct(176,607,198,632,226,649) +ct(254,667,284,675,316,675) +ct(357,675,388,664,409,642) +ct(430,620,440,598,440,576) +ct(440,565,436,556,428,548) +ct(420,540,411,536,402,536) +ct(389,536,379,542,371,554) +ct(368,560,365,573,364,592) +ct(362,611,357,626,347,635) +ct(337,643,323,648,305,648) +ct(279,648,258,638,241,618) +ct(224,598,216,562,216,512) +ct(216,488,218,457,222,420) +ct(224,396,225,378,227,368) +lt(353,368) +lt(353,321) + )cp +dr +ah((145,83) +ct(138,88,131,91,124,94) +ct(117,96,110,97,104,97) +ct(89,97,77,93,69,85) +ct(61,77,57,67,57,54) +ct(57,42,60,33,67,26) +ct(73,20,80,16,89,16) +ct(100,16,110,21,120,31) +ct(131,41,139,59,145,83) + )cp +endchar; + +beginchar(165,500*FX#,662*FY#,0*FY#); +"yen"; +dr +ah((291,207) +lt(499,207) +lt(499,171) +lt(291,171) +lt(291,119) +ct(291,82,292,59,296,49) +ct(299,41,305,35,313,30) +ct(325,23,338,20,354,20) +lt(375,20) +lt(375,0) +lt(123,0) +lt(123,20) +lt(139,20) +ct(161,20,178,24,189,32) +ct(197,38,202,47,206,60) +ct(207,66,208,85,208,119) +lt(208,171) +lt(0,171) +lt(0,207) +lt(208,207) +lt(208,277) +lt(200,295) +lt(0,295) +lt(0,331) +lt(185,331) +lt(81,573) +ct(69,601,57,620,45,629) +ct(34,638,19,643,0,643) +lt(0,662) +lt(216,662) +lt(216,643) +ct(193,641,177,638,169,632) +ct(161,626,157,620,157,613) +ct(157,607,160,598,166,584) +lt(270,331) +lt(375,577) +ct(381,593,385,605,385,613) +ct(385,620,381,627,375,633) +ct(370,637,359,640,343,642) +ct(340,642,336,642,330,643) +lt(330,662) +lt(499,662) +lt(499,643) +ct(479,643,465,639,457,632) +ct(443,620,429,599,415,567) +lt(310,331) +lt(499,331) +lt(499,295) +lt(294,295) +lt(291,287) +lt(291,207) + )cp +endchar; + +beginchar(167,500*FX#,675*FY#,195*FY#); +"section"; +dr +ah((184,411) +ct(162,435,146,457,137,477) +ct(128,497,123,517,123,538) +ct(123,576,136,608,163,635) +ct(190,662,223,675,262,675) +ct(298,675,327,664,350,643) +ct(374,621,385,596,385,568) +ct(385,555,381,544,373,534) +ct(366,527,357,524,347,524) +ct(336,524,326,528,319,535) +ct(312,543,309,551,309,562) +ct(309,566,310,575,312,587) +ct(314,595,315,602,315,608) +ct(315,622,310,633,301,642) +ct(291,650,278,655,262,655) +ct(238,655,218,646,201,630) +ct(185,613,177,593,177,569) +ct(177,548,181,531,190,518) +ct(204,494,229,470,264,446) +ct(329,398,374,356,398,319) +ct(414,292,423,264,423,235) +ct(423,205,415,176,397,146) +ct(380,116,353,90,315,68) +ct(338,43,354,21,363,3) +ct(371,-14,375,-34,375,-55) +ct(375,-95,362,-128,335,-155) +ct(309,-181,276,-195,237,-195) +ct(202,-195,172,-184,149,-161) +ct(126,-139,114,-114,114,-85) +ct(114,-73,118,-63,126,-54) +ct(133,-46,142,-42,152,-42) +ct(162,-42,171,-46,178,-53) +ct(185,-61,189,-71,189,-84) +ct(189,-93,188,-103,185,-114) +ct(182,-124,181,-132,181,-138) +ct(181,-147,185,-155,193,-161) +ct(205,-171,221,-176,240,-176) +ct(262,-176,281,-167,299,-150) +ct(317,-133,326,-115,326,-95) +ct(326,-75,321,-57,311,-41) +ct(295,-16,266,11,226,41) +ct(164,86,123,126,101,162) +ct(84,188,76,216,76,246) +ct(76,276,84,305,102,334) +ct(120,363,147,389,184,411) + )cp +dr +ah((199,396) +ct(149,366,125,330,125,288) +ct(125,264,131,243,144,225) +ct(160,198,192,167,240,131) +ct(262,113,282,97,299,82) +ct(349,112,374,147,374,189) +ct(374,211,367,233,353,256) +ct(338,279,309,307,264,342) +ct(237,362,215,380,199,396) + )cp +endchar; + +beginchar(132,500*FX#,677*FY#,210*FY#); +"florin"; +dr +ah((335,427) +lt(422,427) +lt(414,395) +lt(329,395) +ct(311,307,283,191,245,49) +ct(214,-61,181,-134,145,-169) +ct(117,-196,89,-210,60,-210) +ct(42,-210,27,-205,17,-195) +ct(6,-185,0,-173,0,-159) +ct(0,-146,4,-136,12,-127) +ct(20,-119,28,-115,38,-115) +ct(47,-115,54,-118,60,-124) +ct(67,-130,70,-136,70,-143) +ct(70,-149,67,-155,63,-161) +ct(59,-165,58,-168,58,-170) +ct(58,-173,59,-175,62,-177) +ct(64,-180,67,-181,70,-181) +ct(76,-181,82,-179,88,-176) +ct(98,-170,108,-160,117,-145) +ct(127,-129,136,-100,146,-58) +ct(148,-50,162,16,188,144) +ct(190,155,211,239,249,395) +lt(162,395) +lt(169,427) +ct(202,429,222,432,230,434) +ct(239,437,245,442,251,450) +ct(259,460,269,482,280,515) +ct(304,584,327,628,349,648) +ct(370,667,394,677,420,677) +ct(441,677,457,671,469,661) +ct(481,650,487,637,487,622) +ct(487,611,484,602,478,595) +ct(471,588,463,584,454,584) +ct(446,584,438,587,432,593) +ct(426,599,423,605,423,612) +ct(423,617,425,623,429,629) +ct(432,635,434,639,434,642) +ct(434,645,432,648,430,651) +ct(426,653,422,654,417,654) +ct(406,654,397,650,389,643) +ct(377,631,370,618,366,602) +ct(357,562,347,503,335,427) + )cp +endchar; + +beginchar(162,500*FX#,647*FY#,185*FY#); +"cent"; +dr +ah((439,170) +ct(423,108,397,61,359,27) +ct(329,1,293,-11,251,-11) +ct(225,-11,198,-5,172,5) +lt(103,-185) +lt(69,-185) +lt(145,23) +ct(118,47,99,72,87,98) +ct(70,134,62,174,62,220) +ct(62,302,87,366,139,411) +ct(178,445,222,462,272,462) +ct(278,462,288,461,302,460) +lt(371,647) +lt(406,647) +lt(335,451) +ct(367,436,390,422,402,408) +ct(418,390,426,372,426,352) +ct(426,339,422,329,414,322) +ct(406,314,395,311,380,311) +ct(362,311,348,317,338,329) +ct(332,336,327,349,325,369) +ct(323,379,321,389,317,401) +lt(206,93) +ct(224,80,239,72,251,68) +ct(260,64,271,63,285,63) +ct(305,63,324,67,342,75) +ct(361,84,374,93,384,105) +ct(393,116,407,140,424,176) +lt(439,170) + )cp +dr +ah((180,122) +lt(289,422) +ct(279,426,270,428,260,428) +ct(226,428,200,416,181,392) +ct(154,359,141,315,141,261) +ct(141,236,143,214,149,193) +ct(155,173,165,149,180,122) + )cp +endchar; + +beginchar(226,443*FX#,676*FY#,9*FY#); +"acircumflex"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +dr +ah((178,676) +lt(268,676) +lt(361,514) +lt(346,514) +lt(212,618) +lt(101,514) +lt(86,514) +lt(178,676) + )cp +endchar; + +beginchar(234,443*FX#,676*FY#,13*FY#); +"ecircumflex"; +dr +ah((106,278) +ct(105,212,121,160,154,122) +ct(186,84,225,65,269,65) +ct(298,65,324,73,345,90) +ct(367,106,385,133,400,172) +lt(415,163) +ct(408,118,388,77,355,41) +ct(323,4,281,-13,232,-13) +ct(178,-13,132,7,94,49) +ct(56,90,37,147,37,217) +ct(37,294,56,353,95,396) +ct(135,439,184,460,243,460) +ct(293,460,334,444,367,411) +ct(399,378,415,334,415,278) +lt(106,278) + )cp +dr +ah((106,307) +lt(313,307) +ct(311,335,308,355,303,367) +ct(295,385,282,400,266,410) +ct(250,421,233,426,216,426) +ct(189,426,165,415,143,394) +ct(122,373,110,344,106,307) + )cp +dr +ah((196,676) +lt(286,676) +lt(379,514) +lt(364,514) +lt(230,618) +lt(119,514) +lt(104,514) +lt(196,676) + )cp +endchar; + +beginchar(244,500*FX#,676*FY#,13*FY#); +"ocircumflex"; +dr +ah((250,460) +ct(317,460,371,434,413,383) +ct(447,339,465,288,465,231) +ct(465,191,455,151,436,110) +ct(417,69,390,38,357,17) +ct(323,-3,285,-13,244,-13) +ct(176,-13,123,13,83,66) +ct(49,111,33,162,33,219) +ct(33,260,43,301,64,341) +ct(84,382,111,412,144,431) +ct(177,450,212,460,250,460) + )cp +dr +ah((234,428) +ct(217,428,200,423,182,413) +ct(165,403,151,385,140,359) +ct(129,333,124,300,124,260) +ct(124,195,137,138,163,91) +ct(189,44,223,20,265,20) +ct(297,20,323,34,343,60) +ct(364,86,374,130,374,194) +ct(374,273,357,335,323,381) +ct(299,412,270,428,234,428) + )cp +dr +ah((210,676) +lt(300,676) +lt(393,514) +lt(377,514) +lt(244,618) +lt(132,514) +lt(118,514) +lt(210,676) + )cp +endchar; + +beginchar(251,500*FX#,676*FY#,13*FY#); +"ucircumflex"; +dr +ah((423,447) +lt(423,176) +ct(423,124,424,92,427,81) +ct(429,69,433,61,438,57) +ct(444,52,450,50,457,50) +ct(467,50,478,52,491,58) +lt(498,41) +lt(364,-13) +lt(342,-13) +lt(342,81) +ct(304,39,275,13,254,2) +ct(234,-8,213,-13,190,-13) +ct(165,-13,144,-6,125,8) +ct(107,22,94,41,87,63) +ct(80,86,76,118,76,160) +lt(76,360) +ct(76,381,74,396,69,404) +ct(65,412,58,418,49,423) +ct(40,427,24,429,0,429) +lt(0,447) +lt(157,447) +lt(157,147) +ct(157,106,164,78,179,65) +ct(193,52,211,46,231,46) +ct(245,46,261,50,279,59) +ct(297,68,318,85,342,109) +lt(342,363) +ct(342,388,338,405,328,414) +ct(319,423,300,428,270,429) +lt(270,447) +lt(423,447) + )cp +dr +ah((206,676) +lt(296,676) +lt(389,514) +lt(374,514) +lt(240,618) +lt(128,514) +lt(114,514) +lt(206,676) + )cp +endchar; + +beginchar(225,443*FX#,678*FY#,9*FY#); +"aacute"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +dr +ah((333,678) +lt(188,510) +lt(172,510) +lt(223,678) +lt(333,678) + )cp +endchar; + +beginchar(233,443*FX#,678*FY#,13*FY#); +"eacute"; +dr +ah((106,278) +ct(105,212,121,160,154,122) +ct(186,84,225,65,269,65) +ct(298,65,324,73,345,90) +ct(367,106,385,133,400,172) +lt(415,163) +ct(408,118,388,77,355,41) +ct(323,4,281,-13,232,-13) +ct(178,-13,132,7,94,49) +ct(56,90,37,147,37,217) +ct(37,294,56,353,95,396) +ct(135,439,184,460,243,460) +ct(293,460,334,444,367,411) +ct(399,378,415,334,415,278) +lt(106,278) + )cp +dr +ah((106,307) +lt(313,307) +ct(311,335,308,355,303,367) +ct(295,385,282,400,266,410) +ct(250,421,233,426,216,426) +ct(189,426,165,415,143,394) +ct(122,373,110,344,106,307) + )cp +dr +ah((339,678) +lt(195,510) +lt(178,510) +lt(229,678) +lt(339,678) + )cp +endchar; + +beginchar(243,500*FX#,678*FY#,13*FY#); +"oacute"; +dr +ah((250,460) +ct(317,460,371,434,413,383) +ct(447,339,465,288,465,231) +ct(465,191,455,151,436,110) +ct(417,69,390,38,357,17) +ct(323,-3,285,-13,244,-13) +ct(176,-13,123,13,83,66) +ct(49,111,33,162,33,219) +ct(33,260,43,301,64,341) +ct(84,382,111,412,144,431) +ct(177,450,212,460,250,460) + )cp +dr +ah((234,428) +ct(217,428,200,423,182,413) +ct(165,403,151,385,140,359) +ct(129,333,124,300,124,260) +ct(124,195,137,138,163,91) +ct(189,44,223,20,265,20) +ct(297,20,323,34,343,60) +ct(364,86,374,130,374,194) +ct(374,273,357,335,323,381) +ct(299,412,270,428,234,428) + )cp +dr +ah((353,678) +lt(208,510) +lt(192,510) +lt(243,678) +lt(353,678) + )cp +endchar; + +beginchar(250,500*FX#,678*FY#,13*FY#); +"uacute"; +dr +ah((423,447) +lt(423,176) +ct(423,124,424,92,427,81) +ct(429,69,433,61,438,57) +ct(444,52,450,50,457,50) +ct(467,50,478,52,491,58) +lt(498,41) +lt(364,-13) +lt(342,-13) +lt(342,81) +ct(304,39,275,13,254,2) +ct(234,-8,213,-13,190,-13) +ct(165,-13,144,-6,125,8) +ct(107,22,94,41,87,63) +ct(80,86,76,118,76,160) +lt(76,360) +ct(76,381,74,396,69,404) +ct(65,412,58,418,49,423) +ct(40,427,24,429,0,429) +lt(0,447) +lt(157,447) +lt(157,147) +ct(157,106,164,78,179,65) +ct(193,52,211,46,231,46) +ct(245,46,261,50,279,59) +ct(297,68,318,85,342,109) +lt(342,363) +ct(342,388,338,405,328,414) +ct(319,423,300,428,270,429) +lt(270,447) +lt(423,447) + )cp +dr +ah((341,678) +lt(197,510) +lt(180,510) +lt(231,678) +lt(341,678) + )cp +endchar; + +beginchar(224,443*FX#,678*FY#,9*FY#); +"agrave"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +dr +ah((126,678) +lt(235,678) +lt(287,510) +lt(270,510) +lt(126,678) + )cp +endchar; + +beginchar(232,443*FX#,678*FY#,13*FY#); +"egrave"; +dr +ah((106,278) +ct(105,212,121,160,154,122) +ct(186,84,225,65,269,65) +ct(298,65,324,73,345,90) +ct(367,106,385,133,400,172) +lt(415,163) +ct(408,118,388,77,355,41) +ct(323,4,281,-13,232,-13) +ct(178,-13,132,7,94,49) +ct(56,90,37,147,37,217) +ct(37,294,56,353,95,396) +ct(135,439,184,460,243,460) +ct(293,460,334,444,367,411) +ct(399,378,415,334,415,278) +lt(106,278) + )cp +dr +ah((106,307) +lt(313,307) +ct(311,335,308,355,303,367) +ct(295,385,282,400,266,410) +ct(250,421,233,426,216,426) +ct(189,426,165,415,143,394) +ct(122,373,110,344,106,307) + )cp +dr +ah((139,678) +lt(248,678) +lt(299,510) +lt(282,510) +lt(139,678) + )cp +endchar; + +beginchar(242,500*FX#,678*FY#,13*FY#); +"ograve"; +dr +ah((250,460) +ct(317,460,371,434,413,383) +ct(447,339,465,288,465,231) +ct(465,191,455,151,436,110) +ct(417,69,390,38,357,17) +ct(323,-3,285,-13,244,-13) +ct(176,-13,123,13,83,66) +ct(49,111,33,162,33,219) +ct(33,260,43,301,64,341) +ct(84,382,111,412,144,431) +ct(177,450,212,460,250,460) + )cp +dr +ah((234,428) +ct(217,428,200,423,182,413) +ct(165,403,151,385,140,359) +ct(129,333,124,300,124,260) +ct(124,195,137,138,163,91) +ct(189,44,223,20,265,20) +ct(297,20,323,34,343,60) +ct(364,86,374,130,374,194) +ct(374,273,357,335,323,381) +ct(299,412,270,428,234,428) + )cp +dr +ah((146,678) +lt(255,678) +lt(307,510) +lt(290,510) +lt(146,678) + )cp +endchar; + +beginchar(249,500*FX#,678*FY#,13*FY#); +"ugrave"; +dr +ah((423,447) +lt(423,176) +ct(423,124,424,92,427,81) +ct(429,69,433,61,438,57) +ct(444,52,450,50,457,50) +ct(467,50,478,52,491,58) +lt(498,41) +lt(364,-13) +lt(342,-13) +lt(342,81) +ct(304,39,275,13,254,2) +ct(234,-8,213,-13,190,-13) +ct(165,-13,144,-6,125,8) +ct(107,22,94,41,87,63) +ct(80,86,76,118,76,160) +lt(76,360) +ct(76,381,74,396,69,404) +ct(65,412,58,418,49,423) +ct(40,427,24,429,0,429) +lt(0,447) +lt(157,447) +lt(157,147) +ct(157,106,164,78,179,65) +ct(193,52,211,46,231,46) +ct(245,46,261,50,279,59) +ct(297,68,318,85,342,109) +lt(342,363) +ct(342,388,338,405,328,414) +ct(319,423,300,428,270,429) +lt(270,447) +lt(423,447) + )cp +dr +ah((149,678) +lt(258,678) +lt(310,510) +lt(293,510) +lt(149,678) + )cp +endchar; + +beginchar(228,443*FX#,652*FY#,9*FY#); +"adieresis"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +dr +ah((309,652) +ct(324,652,336,647,346,637) +ct(357,626,362,614,362,599) +ct(362,584,357,572,346,562) +ct(336,552,324,546,309,546) +ct(294,546,282,552,271,562) +ct(261,572,256,584,256,599) +ct(256,614,261,626,271,637) +ct(282,647,294,652,309,652) + )cp +dr +ah((137,652) +ct(152,652,164,647,175,637) +ct(185,626,190,614,190,599) +ct(190,584,185,572,174,562) +ct(164,552,152,546,137,546) +ct(123,546,110,552,100,562) +ct(89,572,84,584,84,599) +ct(84,614,89,626,99,637) +ct(110,647,122,652,137,652) + )cp +endchar; + +beginchar(235,443*FX#,652*FY#,13*FY#); +"edieresis"; +dr +ah((106,278) +ct(105,212,121,160,154,122) +ct(186,84,225,65,269,65) +ct(298,65,324,73,345,90) +ct(367,106,385,133,400,172) +lt(415,163) +ct(408,118,388,77,355,41) +ct(323,4,281,-13,232,-13) +ct(178,-13,132,7,94,49) +ct(56,90,37,147,37,217) +ct(37,294,56,353,95,396) +ct(135,439,184,460,243,460) +ct(293,460,334,444,367,411) +ct(399,378,415,334,415,278) +lt(106,278) + )cp +dr +ah((106,307) +lt(313,307) +ct(311,335,308,355,303,367) +ct(295,385,282,400,266,410) +ct(250,421,233,426,216,426) +ct(189,426,165,415,143,394) +ct(122,373,110,344,106,307) + )cp +dr +ah((327,652) +ct(342,652,354,647,364,636) +ct(375,626,380,613,380,599) +ct(380,584,375,572,364,561) +ct(354,551,342,546,327,546) +ct(312,546,300,551,290,561) +ct(279,572,274,584,274,599) +ct(274,613,279,626,290,636) +ct(300,647,312,652,327,652) + )cp +dr +ah((155,652) +ct(170,652,182,647,193,636) +ct(203,626,208,613,208,599) +ct(208,584,203,572,192,561) +ct(182,551,170,546,155,546) +ct(141,546,128,551,118,561) +ct(107,572,102,584,102,599) +ct(102,613,107,626,117,636) +ct(128,647,140,652,155,652) + )cp +endchar; + +beginchar(246,500*FX#,652*FY#,13*FY#); +"odieresis"; +dr +ah((250,460) +ct(317,460,371,434,413,383) +ct(447,339,465,288,465,231) +ct(465,191,455,151,436,110) +ct(417,69,390,38,357,17) +ct(323,-3,285,-13,244,-13) +ct(176,-13,123,13,83,66) +ct(49,111,33,162,33,219) +ct(33,260,43,301,64,341) +ct(84,382,111,412,144,431) +ct(177,450,212,460,250,460) + )cp +dr +ah((234,428) +ct(217,428,200,423,182,413) +ct(165,403,151,385,140,359) +ct(129,333,124,300,124,260) +ct(124,195,137,138,163,91) +ct(189,44,223,20,265,20) +ct(297,20,323,34,343,60) +ct(364,86,374,130,374,194) +ct(374,273,357,335,323,381) +ct(299,412,270,428,234,428) + )cp +dr +ah((335,652) +ct(350,652,362,647,372,636) +ct(383,626,388,613,388,599) +ct(388,584,383,572,372,561) +ct(362,551,350,546,335,546) +ct(320,546,308,551,297,561) +ct(287,572,282,584,282,599) +ct(282,613,287,626,297,636) +ct(308,647,320,652,335,652) + )cp +dr +ah((163,652) +ct(178,652,190,647,200,636) +ct(211,626,216,613,216,599) +ct(216,584,211,572,200,561) +ct(190,551,177,546,163,546) +ct(148,546,136,551,125,561) +ct(115,572,110,584,110,599) +ct(110,613,115,626,125,636) +ct(135,647,148,652,163,652) + )cp +endchar; + +beginchar(252,500*FX#,652*FY#,13*FY#); +"udieresis"; +dr +ah((423,447) +lt(423,176) +ct(423,124,424,92,427,81) +ct(429,69,433,61,438,57) +ct(444,52,450,50,457,50) +ct(467,50,478,52,491,58) +lt(498,41) +lt(364,-13) +lt(342,-13) +lt(342,81) +ct(304,39,275,13,254,2) +ct(234,-8,213,-13,190,-13) +ct(165,-13,144,-6,125,8) +ct(107,22,94,41,87,63) +ct(80,86,76,118,76,160) +lt(76,360) +ct(76,381,74,396,69,404) +ct(65,412,58,418,49,423) +ct(40,427,24,429,0,429) +lt(0,447) +lt(157,447) +lt(157,147) +ct(157,106,164,78,179,65) +ct(193,52,211,46,231,46) +ct(245,46,261,50,279,59) +ct(297,68,318,85,342,109) +lt(342,363) +ct(342,388,338,405,328,414) +ct(319,423,300,428,270,429) +lt(270,447) +lt(423,447) + )cp +dr +ah((335,652) +ct(350,652,362,647,372,636) +ct(383,626,388,613,388,599) +ct(388,584,383,572,372,561) +ct(362,551,350,546,335,546) +ct(320,546,308,551,297,561) +ct(287,572,282,584,282,599) +ct(282,613,287,626,297,636) +ct(308,647,320,652,335,652) + )cp +dr +ah((163,652) +ct(178,652,190,647,200,636) +ct(211,626,216,613,216,599) +ct(216,584,211,572,200,561) +ct(190,551,177,546,163,546) +ct(148,546,136,551,125,561) +ct(115,572,110,584,110,599) +ct(110,613,115,626,125,636) +ct(135,647,148,652,163,652) + )cp +endchar; + +beginchar(197,722*FX#,830*FY#,0*FY#); +"Aring"; +dr +ah((456,221) +lt(200,221) +lt(155,117) +ct(143,91,138,71,138,59) +ct(138,49,143,40,153,32) +ct(162,25,183,20,215,18) +lt(215,0) +lt(6,0) +lt(6,18) +ct(34,22,52,29,60,37) +ct(76,52,95,84,115,132) +lt(348,677) +lt(365,677) +lt(596,126) +ct(614,82,631,53,646,40) +ct(661,27,682,19,709,18) +lt(709,0) +lt(448,0) +lt(448,18) +ct(475,19,492,23,502,31) +ct(511,38,516,47,516,58) +ct(516,72,509,95,496,126) +lt(456,221) + )cp +dr +ah((442,257) +lt(330,525) +lt(215,257) +lt(442,257) + )cp +dr +ah((356,830) +ct(382,830,405,821,423,803) +ct(441,784,450,763,450,737) +ct(450,711,441,689,423,670) +ct(405,652,382,643,356,643) +ct(331,643,309,652,291,670) +ct(272,689,263,711,263,737) +ct(263,763,272,784,290,803) +ct(308,821,330,830,356,830) + )cp +dr +ah((356,796) +ct(340,796,326,791,314,779) +ct(303,767,297,753,297,737) +ct(297,721,303,707,314,695) +ct(326,683,340,677,356,677) +ct(373,677,387,683,399,695) +ct(410,707,416,721,416,737) +ct(416,753,410,767,399,779) +ct(387,791,373,796,356,796) + )cp +endchar; + +beginchar(238,277*FX#,676*FY#,0*FY#); +"icircumflex"; +dr +ah((185,460) +lt(185,101) +ct(185,73,187,54,191,45) +ct(195,35,201,28,209,24) +ct(217,19,232,17,253,17) +lt(253,0) +lt(36,0) +lt(36,17) +ct(57,17,72,19,80,23) +ct(87,28,93,35,97,44) +ct(102,54,104,73,104,101) +lt(104,273) +ct(104,321,102,353,100,367) +ct(97,378,94,385,89,389) +ct(84,393,77,395,69,395) +ct(59,395,48,392,36,388) +lt(29,405) +lt(164,460) +lt(185,460) + )cp +dr +ah((98,676) +lt(188,676) +lt(281,514) +lt(266,514) +lt(132,618) +lt(20,514) +lt(6,514) +lt(98,676) + )cp +endchar; + +beginchar(31,722*FX#,683*FY#,22*FY#); +"Oslash"; +dr +ah((560,604) +lt(624,683) +lt(652,662) +lt(587,580) +ct(621,543,645,506,661,468) +ct(676,430,684,386,684,335) +ct(684,223,644,132,564,64) +ct(503,11,436,-15,363,-15) +ct(329,-15,294,-9,257,3) +ct(220,15,188,32,161,54) +lt(98,-22) +lt(69,0) +lt(133,80) +ct(67,147,35,233,35,337) +ct(35,433,67,514,131,579) +ct(195,644,271,677,361,677) +ct(435,677,501,652,560,604) + )cp +dr +ah((519,554) +ct(481,612,427,642,359,642) +ct(328,642,304,638,287,631) +ct(262,621,240,606,222,584) +ct(196,556,177,521,165,479) +ct(153,438,147,392,147,340) +ct(147,264,159,198,183,141) +lt(519,554) + )cp +dr +ah((537,519) +lt(203,105) +ct(220,78,239,59,259,47) +ct(288,29,320,20,356,20) +ct(390,20,418,25,440,35) +ct(462,45,482,61,501,83) +ct(520,104,537,134,550,173) +ct(564,212,571,261,571,320) +ct(571,360,568,397,562,431) +ct(557,456,549,485,537,519) + )cp +endchar; + +beginchar(29,889*FX#,662*FY#,0*FY#); +"AE"; +dr +ah((501,625) +lt(501,364) +lt(626,364) +ct(664,364,690,371,706,385) +ct(721,399,730,424,732,460) +lt(750,460) +lt(750,230) +lt(732,230) +ct(729,263,723,284,717,296) +ct(710,307,699,316,683,323) +ct(675,326,656,328,626,328) +lt(501,328) +lt(501,109) +ct(501,79,502,62,504,56) +ct(507,50,511,45,519,41) +ct(526,38,539,36,557,36) +lt(646,36) +ct(681,36,709,39,728,44) +ct(747,50,766,62,784,79) +ct(807,101,826,130,842,166) +lt(861,166) +lt(808,0) +lt(311,0) +lt(311,18) +lt(336,18) +ct(362,18,382,25,395,41) +ct(403,51,407,76,407,116) +lt(407,256) +lt(214,256) +lt(153,142) +ct(130,99,119,71,119,58) +ct(119,48,124,40,134,32) +ct(144,25,165,20,196,18) +lt(196,0) +lt(-11,0) +lt(-11,18) +ct(2,18,14,21,25,27) +ct(35,33,46,43,58,59) +ct(70,74,85,99,104,133) +lt(305,510) +ct(330,556,343,588,343,604) +ct(343,614,338,622,330,628) +ct(318,636,294,642,258,644) +lt(258,662) +lt(801,662) +lt(808,516) +lt(791,516) +ct(787,549,779,575,767,593) +ct(758,605,745,615,729,621) +ct(719,623,697,625,663,625) +lt(501,625) + )cp +dr +ah((407,625) +lt(233,291) +lt(407,291) +lt(407,625) + )cp +endchar; + +beginchar(229,443*FX#,696*FY#,9*FY#); +"aring"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +dr +ah((223,696) +ct(249,696,271,687,290,668) +ct(308,650,317,628,317,603) +ct(317,576,308,554,290,536) +ct(271,518,249,509,223,509) +ct(197,509,175,518,157,536) +ct(139,554,130,576,130,603) +ct(130,628,139,650,157,668) +ct(175,687,197,696,223,696) + )cp +dr +ah((223,662) +ct(207,662,192,656,181,645) +ct(169,633,164,619,164,603) +ct(164,586,169,572,181,561) +ct(192,549,207,543,223,543) +ct(240,543,254,549,265,561) +ct(277,572,283,586,283,603) +ct(283,619,277,633,265,645) +ct(254,656,240,662,223,662) + )cp +endchar; + +beginchar(237,277*FX#,678*FY#,0*FY#); +"iacute"; +dr +ah((185,460) +lt(185,101) +ct(185,73,187,54,191,45) +ct(195,35,201,28,209,24) +ct(217,19,232,17,253,17) +lt(253,0) +lt(36,0) +lt(36,17) +ct(57,17,72,19,80,23) +ct(87,28,93,35,97,44) +ct(102,54,104,73,104,101) +lt(104,273) +ct(104,321,102,353,100,367) +ct(97,378,94,385,89,389) +ct(84,393,77,395,69,395) +ct(59,395,48,392,36,388) +lt(29,405) +lt(164,460) +lt(185,460) + )cp +dr +ah((243,678) +lt(99,510) +lt(82,510) +lt(133,678) +lt(243,678) + )cp +endchar; + +beginchar(28,500*FX#,478*FY#,32*FY#); +"oslash"; +dr +ah((393,406) +lt(458,478) +lt(480,457) +lt(415,382) +ct(449,338,466,287,466,230) +ct(466,192,457,152,438,111) +ct(419,69,393,38,360,17) +ct(326,-3,289,-13,247,-13) +ct(220,-13,196,-9,175,-1) +ct(154,7,132,21,107,41) +lt(41,-32) +lt(19,-11) +lt(87,65) +ct(71,86,58,110,49,140) +ct(40,169,36,196,36,222) +ct(36,260,45,299,65,339) +ct(85,378,111,408,145,429) +ct(178,450,214,460,254,460) +ct(281,460,305,456,326,447) +ct(348,439,370,425,393,406) + )cp +dr +ah((343,351) +ct(327,380,310,400,294,411) +ct(278,422,259,428,238,428) +ct(206,428,179,415,158,389) +ct(137,363,126,319,126,259) +ct(126,219,132,176,145,131) +lt(343,351) + )cp +dr +ah((357,319) +lt(160,99) +ct(177,69,193,49,209,37) +ct(225,26,244,20,267,20) +ct(299,20,325,34,345,60) +ct(366,86,376,131,376,196) +ct(376,235,369,276,357,319) + )cp +endchar; + +beginchar(26,666*FX#,460*FY#,13*FY#); +"ae"; +dr +ah((358,276) +ct(357,259,357,247,357,240) +ct(357,175,369,128,393,101) +ct(416,73,446,59,482,59) +ct(514,59,542,69,568,89) +ct(584,101,602,127,621,166) +lt(636,156) +ct(624,103,599,59,561,24) +ct(533,0,498,-13,456,-13) +ct(420,-13,390,-5,365,9) +ct(353,16,335,34,311,64) +ct(307,61,298,54,284,43) +ct(265,27,252,18,246,15) +ct(231,6,215,0,197,-5) +ct(180,-11,162,-13,144,-13) +ct(113,-13,88,-2,67,18) +ct(46,40,35,66,35,98) +ct(35,126,42,150,56,170) +ct(71,190,98,210,140,231) +ct(190,257,235,277,274,291) +lt(274,336) +ct(274,371,268,396,255,410) +ct(242,425,224,432,203,432) +ct(181,432,164,426,152,416) +ct(140,405,134,393,134,381) +ct(134,354,132,336,130,328) +ct(127,319,123,313,117,309) +ct(111,305,104,303,95,303) +ct(82,303,72,306,65,314) +ct(55,324,51,336,51,349) +ct(51,366,57,383,69,400) +ct(80,417,99,431,125,443) +ct(150,455,180,460,214,460) +ct(255,460,285,455,306,443) +ct(326,432,340,417,346,400) +ct(362,420,378,434,395,443) +ct(418,454,446,460,478,460) +ct(524,460,563,445,592,413) +ct(621,381,636,336,636,276) +lt(358,276) + )cp +dr +ah((358,308) +lt(542,308) +ct(542,349,533,379,516,398) +ct(500,416,478,426,452,426) +ct(426,426,404,416,386,395) +ct(368,375,359,346,358,308) + )cp +dr +ah((297,89) +ct(291,104,285,123,281,147) +ct(277,170,274,193,274,216) +lt(274,259) +ct(230,245,189,225,153,197) +ct(129,178,117,154,117,125) +ct(117,100,125,79,140,62) +ct(156,46,174,38,196,38) +ct(208,38,222,41,236,48) +ct(250,55,271,69,297,89) + )cp +endchar; + +beginchar(196,722*FX#,833*FY#,0*FY#); +"Adieresis"; +dr +ah((456,221) +lt(200,221) +lt(155,117) +ct(143,91,138,71,138,59) +ct(138,49,143,40,153,32) +ct(162,25,183,20,215,18) +lt(215,0) +lt(6,0) +lt(6,18) +ct(34,22,52,29,60,37) +ct(76,52,95,84,115,132) +lt(348,677) +lt(365,677) +lt(596,126) +ct(614,82,631,53,646,40) +ct(661,27,682,19,709,18) +lt(709,0) +lt(448,0) +lt(448,18) +ct(475,19,492,23,502,31) +ct(511,38,516,47,516,58) +ct(516,72,509,95,496,126) +lt(456,221) + )cp +dr +ah((442,257) +lt(330,525) +lt(215,257) +lt(442,257) + )cp +dr +ah((444,833) +ct(459,833,471,828,482,818) +ct(492,807,497,795,497,780) +ct(497,766,492,753,482,743) +ct(471,733,459,728,444,728) +ct(430,728,417,733,407,743) +ct(396,753,391,766,391,780) +ct(391,795,396,807,407,818) +ct(417,828,430,833,444,833) + )cp +dr +ah((272,833) +ct(287,833,300,828,310,818) +ct(320,807,325,795,325,780) +ct(325,766,320,753,310,743) +ct(299,733,287,728,272,728) +ct(258,728,245,733,235,743) +ct(224,753,219,766,219,780) +ct(219,795,224,807,235,818) +ct(245,828,257,833,272,833) + )cp +endchar; + +beginchar(236,277*FX#,678*FY#,0*FY#); +"igrave"; +dr +ah((185,460) +lt(185,101) +ct(185,73,187,54,191,45) +ct(195,35,201,28,209,24) +ct(217,19,232,17,253,17) +lt(253,0) +lt(36,0) +lt(36,17) +ct(57,17,72,19,80,23) +ct(87,28,93,35,97,44) +ct(102,54,104,73,104,101) +lt(104,273) +ct(104,321,102,353,100,367) +ct(97,378,94,385,89,389) +ct(84,393,77,395,69,395) +ct(59,395,48,392,36,388) +lt(29,405) +lt(164,460) +lt(185,460) + )cp +dr +ah((37,678) +lt(146,678) +lt(198,510) +lt(181,510) +lt(37,678) + )cp +endchar; + +beginchar(214,722*FX#,833*FY#,15*FY#); +"Odieresis"; +dr +ah((365,677) +ct(451,677,526,644,589,579) +ct(652,514,683,432,683,334) +ct(683,234,651,150,588,84) +ct(524,18,448,-15,357,-15) +ct(266,-15,190,17,128,82) +ct(66,146,35,230,35,333) +ct(35,438,70,524,142,590) +ct(204,648,278,677,365,677) + )cp +dr +ah((356,641) +ct(296,641,249,619,213,575) +ct(168,520,146,440,146,335) +ct(146,227,169,143,216,85) +ct(251,41,298,19,356,19) +ct(419,19,470,43,510,92) +ct(551,140,571,217,571,321) +ct(571,434,548,519,504,575) +ct(468,619,419,641,356,641) + )cp +dr +ah((443,833) +ct(458,833,470,828,481,818) +ct(491,807,496,795,496,780) +ct(496,766,491,753,481,743) +ct(470,733,458,728,443,728) +ct(429,728,416,733,406,743) +ct(395,753,390,766,390,780) +ct(390,795,395,807,406,818) +ct(416,828,429,833,443,833) + )cp +dr +ah((271,833) +ct(286,833,299,828,309,818) +ct(319,807,324,795,324,780) +ct(324,766,319,753,309,743) +ct(298,733,286,728,271,728) +ct(257,728,244,733,234,743) +ct(223,753,218,766,218,780) +ct(218,795,223,807,234,818) +ct(244,828,256,833,271,833) + )cp +endchar; + +beginchar(220,722*FX#,833*FY#,15*FY#); +"Udieresis"; +dr +ah((477,644) +lt(477,662) +lt(711,662) +lt(711,644) +lt(686,644) +ct(660,644,640,633,626,611) +ct(619,601,616,577,616,541) +lt(616,272) +ct(616,206,609,154,596,117) +ct(583,81,557,49,518,23) +ct(480,-2,427,-15,361,-15) +ct(289,-15,234,-3,196,21) +ct(159,47,132,80,117,123) +ct(106,151,101,206,101,286) +lt(101,544) +ct(101,585,95,612,84,625) +ct(73,637,55,644,30,644) +lt(5,644) +lt(5,662) +lt(291,662) +lt(291,644) +lt(266,644) +ct(238,644,219,635,207,618) +ct(199,606,195,581,195,544) +lt(195,256) +ct(195,230,197,201,202,167) +ct(207,134,215,108,228,90) +ct(240,71,258,56,281,44) +ct(304,32,333,26,367,26) +ct(410,26,449,35,483,54) +ct(517,73,540,97,553,127) +ct(565,156,572,206,572,276) +lt(572,544) +ct(572,585,567,611,558,622) +ct(545,636,526,644,501,644) +lt(477,644) + )cp +dr +ah((468,833) +ct(483,833,495,828,506,818) +ct(516,807,521,795,521,780) +ct(521,766,516,753,506,743) +ct(495,733,483,728,468,728) +ct(454,728,441,733,431,743) +ct(420,753,415,766,415,780) +ct(415,795,420,807,431,818) +ct(441,828,454,833,468,833) + )cp +dr +ah((296,833) +ct(311,833,323,828,334,818) +ct(344,807,349,795,349,780) +ct(349,766,344,753,333,743) +ct(323,733,311,728,296,728) +ct(282,728,269,733,259,743) +ct(248,753,243,766,243,780) +ct(243,795,248,807,259,818) +ct(269,828,281,833,296,833) + )cp +endchar; + +beginchar(201,610*FX#,877*FY#,0*FY#); +"Eacute"; +dr +ah((208,625) +lt(208,364) +lt(354,364) +ct(392,364,417,369,430,381) +ct(446,395,456,422,458,460) +lt(476,460) +lt(476,229) +lt(458,229) +ct(453,261,448,282,444,291) +ct(438,303,429,312,416,318) +ct(402,325,382,328,354,328) +lt(208,328) +lt(208,110) +ct(208,81,210,63,212,56) +ct(215,50,220,45,226,41) +ct(233,38,245,36,263,36) +lt(375,36) +ct(413,36,440,38,457,43) +ct(474,49,490,59,506,74) +ct(526,94,546,124,568,166) +lt(587,166) +lt(530,0) +lt(20,0) +lt(20,18) +lt(43,18) +ct(59,18,74,21,88,29) +ct(98,34,105,42,109,52) +ct(113,63,115,84,115,116) +lt(115,546) +ct(115,588,110,614,102,624) +ct(90,637,70,644,43,644) +lt(20,644) +lt(20,662) +lt(530,662) +lt(538,517) +lt(519,517) +ct(512,551,504,575,496,588) +ct(488,601,475,611,459,618) +ct(445,622,422,625,390,625) +lt(208,625) + )cp +dr +ah((416,877) +lt(272,708) +lt(255,708) +lt(307,877) +lt(416,877) + )cp +endchar; + +beginchar(239,277*FX#,652*FY#,0*FY#); +"idieresis"; +dr +ah((184,460) +lt(184,101) +ct(184,73,186,54,190,45) +ct(195,35,201,28,209,24) +ct(217,19,231,17,252,17) +lt(252,0) +lt(35,0) +lt(35,17) +ct(57,17,72,19,79,23) +ct(87,28,93,35,97,44) +ct(101,54,104,73,104,101) +lt(104,273) +ct(104,321,102,353,99,367) +ct(97,378,93,385,88,389) +ct(83,393,77,395,68,395) +ct(59,395,48,392,35,388) +lt(28,405) +lt(163,460) +lt(184,460) + )cp +dr +ah((252,652) +ct(267,652,279,647,289,636) +ct(300,626,305,613,305,599) +ct(305,584,300,572,289,561) +ct(279,551,267,546,252,546) +ct(237,546,225,551,214,561) +ct(204,572,199,584,199,599) +ct(199,613,204,626,214,636) +ct(225,647,237,652,252,652) + )cp +dr +ah((80,652) +ct(95,652,107,647,117,636) +ct(128,626,133,613,133,599) +ct(133,584,128,572,117,561) +ct(107,551,94,546,80,546) +ct(65,546,53,551,42,561) +ct(32,572,27,584,27,599) +ct(27,613,32,626,42,636) +ct(52,647,65,652,80,652) + )cp +endchar; + +beginchar(25,500*FX#,694*FY#,6*FY#); +"germandbls"; +dr +ah((17,0) +lt(17,17) +ct(36,19,50,22,58,27) +ct(67,33,72,40,76,49) +ct(79,58,81,78,81,109) +lt(81,471) +ct(81,552,96,610,126,644) +ct(156,677,199,694,255,694) +ct(308,694,350,679,381,649) +ct(412,619,427,581,427,535) +ct(427,500,418,471,401,447) +ct(387,429,365,414,334,400) +ct(378,387,411,365,434,333) +ct(456,300,467,258,467,206) +ct(467,149,452,99,423,57) +ct(393,14,354,-6,304,-6) +ct(275,-6,253,1,236,17) +ct(218,32,210,51,210,72) +ct(210,86,213,96,220,104) +ct(227,111,237,115,249,115) +ct(261,115,271,111,278,104) +ct(285,97,289,88,289,76) +ct(289,70,288,65,287,60) +ct(285,52,284,46,284,43) +ct(284,37,286,31,291,27) +ct(295,22,302,20,311,20) +ct(330,20,346,28,359,46) +ct(375,69,384,104,384,152) +ct(384,220,372,273,348,313) +ct(324,353,288,374,240,377) +lt(240,405) +ct(275,405,301,415,319,436) +ct(336,456,345,490,345,538) +ct(345,581,337,613,320,632) +ct(302,652,280,662,251,662) +ct(225,662,204,651,187,630) +ct(170,610,162,568,162,506) +lt(162,0) +lt(17,0) + )cp +endchar; + +beginchar(212,722*FX#,875*FY#,15*FY#); +"Ocircumflex"; +dr +ah((365,677) +ct(451,677,526,644,589,579) +ct(652,514,683,432,683,334) +ct(683,234,651,150,588,84) +ct(524,18,448,-15,357,-15) +ct(266,-15,190,17,128,82) +ct(66,146,35,230,35,333) +ct(35,438,70,524,142,590) +ct(204,648,278,677,365,677) + )cp +dr +ah((356,641) +ct(296,641,249,619,213,575) +ct(168,520,146,440,146,335) +ct(146,227,169,143,216,85) +ct(251,41,298,19,356,19) +ct(419,19,470,43,510,92) +ct(551,140,571,217,571,321) +ct(571,434,548,519,504,575) +ct(468,619,419,641,356,641) + )cp +dr +ah((312,875) +lt(402,875) +lt(495,713) +lt(480,713) +lt(347,817) +lt(235,713) +lt(220,713) +lt(312,875) + )cp +endchar; + +beginchar(193,722*FX#,877*FY#,0*FY#); +"Aacute"; +dr +ah((457,221) +lt(201,221) +lt(156,117) +ct(144,91,139,71,139,59) +ct(139,49,144,40,154,32) +ct(163,25,184,20,216,18) +lt(216,0) +lt(7,0) +lt(7,18) +ct(35,22,53,29,61,37) +ct(77,52,96,84,116,132) +lt(349,677) +lt(366,677) +lt(597,126) +ct(615,82,632,53,647,40) +ct(662,27,683,19,710,18) +lt(710,0) +lt(449,0) +lt(449,18) +ct(476,19,493,23,503,31) +ct(512,38,517,47,517,58) +ct(517,72,510,95,497,126) +lt(457,221) + )cp +dr +ah((443,257) +lt(331,525) +lt(216,257) +lt(443,257) + )cp +dr +ah((468,877) +lt(324,708) +lt(307,708) +lt(358,877) +lt(468,877) + )cp +endchar; + +beginchar(195,722*FX#,841*FY#,0*FY#); +"Atilde"; +dr +ah((456,221) +lt(200,221) +lt(155,117) +ct(143,91,138,71,138,59) +ct(138,49,143,40,153,32) +ct(162,25,183,20,215,18) +lt(215,0) +lt(6,0) +lt(6,18) +ct(34,22,52,29,60,37) +ct(76,52,95,84,115,132) +lt(348,677) +lt(365,677) +lt(596,126) +ct(614,82,631,53,646,40) +ct(661,27,682,19,709,18) +lt(709,0) +lt(448,0) +lt(448,18) +ct(475,19,492,23,502,31) +ct(511,38,516,47,516,58) +ct(516,72,509,95,496,126) +lt(456,221) + )cp +dr +ah((442,257) +lt(330,525) +lt(215,257) +lt(442,257) + )cp +dr +ah((219,715) +lt(203,715) +ct(204,759,214,792,231,812) +ct(248,831,270,841,295,841) +ct(308,841,320,839,332,835) +ct(346,829,367,818,394,800) +ct(421,782,441,773,454,773) +ct(464,773,473,778,481,787) +ct(489,795,495,814,500,841) +lt(515,841) +ct(515,811,511,787,503,769) +ct(495,752,483,738,468,728) +ct(453,718,438,713,422,713) +ct(396,713,365,726,327,752) +ct(306,766,292,774,285,777) +ct(278,780,271,782,264,782) +ct(250,782,240,776,232,764) +ct(228,758,224,742,219,715) + )cp +endchar; + +beginchar(227,443*FX#,662*FY#,9*FY#); +"atilde"; +dr +ah((284,64) +ct(238,28,209,8,198,2) +ct(180,-5,161,-9,142,-9) +ct(111,-9,85,1,65,22) +ct(45,43,35,71,35,105) +ct(35,127,40,146,50,162) +ct(63,184,86,205,119,225) +ct(152,244,207,268,284,296) +lt(284,313) +ct(284,358,277,389,263,405) +ct(249,422,228,430,201,430) +ct(180,430,164,424,152,414) +ct(140,402,134,389,134,375) +lt(135,347) +ct(135,332,131,321,123,312) +ct(116,304,106,300,93,300) +ct(81,300,71,305,64,313) +ct(56,321,52,333,52,348) +ct(52,376,67,401,95,425) +ct(124,448,164,460,216,460) +ct(255,460,287,453,313,440) +ct(332,430,346,414,356,393) +ct(362,379,365,350,365,307) +lt(365,155) +ct(365,112,366,86,367,76) +ct(369,67,371,60,375,57) +ct(379,54,383,52,388,52) +ct(393,52,398,53,402,56) +ct(408,60,421,71,441,91) +lt(441,64) +ct(405,16,370,-8,337,-8) +ct(321,-8,308,-3,299,7) +ct(289,18,284,37,284,64) + )cp +dr +ah((284,96) +lt(284,266) +ct(234,246,203,233,189,225) +ct(163,210,145,195,134,180) +ct(123,164,117,147,117,128) +ct(117,105,124,86,138,70) +ct(152,55,168,47,187,47) +ct(211,47,244,63,284,96) + )cp +dr +ah((83,535) +lt(67,535) +ct(69,580,78,612,95,632) +ct(112,652,134,662,159,662) +ct(172,662,184,659,196,655) +ct(210,650,231,638,258,620) +ct(285,603,305,594,318,594) +ct(328,594,337,598,345,607) +ct(353,616,360,634,364,662) +lt(379,662) +ct(380,631,376,607,367,590) +ct(359,572,347,558,332,548) +ct(317,538,302,533,287,533) +ct(261,533,229,546,191,572) +ct(170,586,157,595,149,598) +ct(142,601,135,602,128,602) +ct(114,602,104,596,97,584) +ct(93,578,88,562,83,535) + )cp +endchar; + +beginchar(205,333*FX#,877*FY#,0*FY#); +"Iacute"; +dr +ah((308,18) +lt(308,0) +lt(24,0) +lt(24,18) +lt(48,18) +ct(75,18,95,25,107,41) +ct(115,51,119,77,119,117) +lt(119,544) +ct(119,578,117,600,113,611) +ct(109,619,103,626,93,632) +ct(78,640,63,644,48,644) +lt(24,644) +lt(24,662) +lt(308,662) +lt(308,644) +lt(284,644) +ct(257,644,237,636,225,620) +ct(217,609,213,584,213,544) +lt(213,117) +ct(213,83,215,60,219,50) +ct(222,42,229,35,240,29) +ct(254,21,268,18,284,18) +lt(308,18) + )cp +dr +ah((275,877) +lt(131,708) +lt(115,708) +lt(166,877) +lt(275,877) + )cp +endchar; + +beginchar(204,333*FX#,877*FY#,0*FY#); +"Igrave"; +dr +ah((308,18) +lt(308,0) +lt(24,0) +lt(24,18) +lt(48,18) +ct(75,18,95,25,107,41) +ct(115,51,119,77,119,117) +lt(119,544) +ct(119,578,117,600,113,611) +ct(109,619,103,626,93,632) +ct(78,640,63,644,48,644) +lt(24,644) +lt(24,662) +lt(308,662) +lt(308,644) +lt(284,644) +ct(257,644,237,636,225,620) +ct(217,609,213,584,213,544) +lt(213,117) +ct(213,83,215,60,219,50) +ct(222,42,229,35,240,29) +ct(254,21,268,18,284,18) +lt(308,18) + )cp +dr +ah((58,877) +lt(166,877) +lt(218,708) +lt(201,708) +lt(58,877) + )cp +endchar; + +beginchar(211,722*FX#,877*FY#,15*FY#); +"Oacute"; +dr +ah((365,677) +ct(451,677,526,644,589,579) +ct(652,514,683,432,683,334) +ct(683,234,651,150,588,84) +ct(524,18,448,-15,357,-15) +ct(266,-15,190,17,128,82) +ct(66,146,35,230,35,333) +ct(35,438,70,524,142,590) +ct(204,648,278,677,365,677) + )cp +dr +ah((356,641) +ct(296,641,249,619,213,575) +ct(168,520,146,440,146,335) +ct(146,227,169,143,216,85) +ct(251,41,298,19,356,19) +ct(419,19,470,43,510,92) +ct(551,140,571,217,571,321) +ct(571,434,548,519,504,575) +ct(468,619,419,641,356,641) + )cp +dr +ah((467,877) +lt(323,708) +lt(306,708) +lt(357,877) +lt(467,877) + )cp +endchar; + +beginchar(210,722*FX#,877*FY#,15*FY#); +"Ograve"; +dr +ah((365,677) +ct(451,677,526,644,589,579) +ct(652,514,683,432,683,334) +ct(683,234,651,150,588,84) +ct(524,18,448,-15,357,-15) +ct(266,-15,190,17,128,82) +ct(66,146,35,230,35,333) +ct(35,438,70,524,142,590) +ct(204,648,278,677,365,677) + )cp +dr +ah((356,641) +ct(296,641,249,619,213,575) +ct(168,520,146,440,146,335) +ct(146,227,169,143,216,85) +ct(251,41,298,19,356,19) +ct(419,19,470,43,510,92) +ct(551,140,571,217,571,321) +ct(571,434,548,519,504,575) +ct(468,619,419,641,356,641) + )cp +dr +ah((249,877) +lt(358,877) +lt(410,708) +lt(393,708) +lt(249,877) + )cp +endchar; + +beginchar(213,722*FX#,841*FY#,15*FY#); +"Otilde"; +dr +ah((365,677) +ct(451,677,526,644,589,579) +ct(652,514,683,432,683,334) +ct(683,234,651,150,588,84) +ct(524,18,448,-15,357,-15) +ct(266,-15,190,17,128,82) +ct(66,146,35,230,35,333) +ct(35,438,70,524,142,590) +ct(204,648,278,677,365,677) + )cp +dr +ah((356,641) +ct(296,641,249,619,213,575) +ct(168,520,146,440,146,335) +ct(146,227,169,143,216,85) +ct(251,41,298,19,356,19) +ct(419,19,470,43,510,92) +ct(551,140,571,217,571,321) +ct(571,434,548,519,504,575) +ct(468,619,419,641,356,641) + )cp +dr +ah((217,715) +lt(202,715) +ct(203,759,212,792,229,812) +ct(247,831,268,841,293,841) +ct(306,841,318,839,330,835) +ct(345,829,365,818,392,800) +ct(419,782,439,773,452,773) +ct(463,773,472,778,480,787) +ct(488,795,494,814,499,841) +lt(514,841) +ct(514,811,510,787,502,769) +ct(493,752,482,738,467,728) +ct(451,718,436,713,421,713) +ct(395,713,363,726,325,752) +ct(305,766,291,774,284,777) +ct(277,780,270,782,263,782) +ct(249,782,239,776,231,764) +ct(227,758,223,742,217,715) + )cp +endchar; + +beginchar(245,500*FX#,662*FY#,13*FY#); +"otilde"; +dr +ah((250,460) +ct(317,460,371,434,413,383) +ct(447,339,465,288,465,231) +ct(465,191,455,151,436,110) +ct(417,69,390,38,357,17) +ct(323,-3,285,-13,244,-13) +ct(176,-13,123,13,83,66) +ct(49,111,33,162,33,219) +ct(33,260,43,301,64,341) +ct(84,382,111,412,144,431) +ct(177,450,212,460,250,460) + )cp +dr +ah((234,428) +ct(217,428,200,423,182,413) +ct(165,403,151,385,140,359) +ct(129,333,124,300,124,260) +ct(124,195,137,138,163,91) +ct(189,44,223,20,265,20) +ct(297,20,323,34,343,60) +ct(364,86,374,130,374,194) +ct(374,273,357,335,323,381) +ct(299,412,270,428,234,428) + )cp +dr +ah((109,535) +lt(93,535) +ct(95,580,104,612,121,632) +ct(138,652,160,662,185,662) +ct(198,662,210,659,222,655) +ct(236,650,257,638,284,620) +ct(311,603,331,594,344,594) +ct(354,594,363,598,371,607) +ct(379,616,386,634,390,662) +lt(405,662) +ct(406,631,402,607,393,590) +ct(385,572,373,558,358,548) +ct(343,538,328,533,312,533) +ct(286,533,255,546,217,572) +ct(196,586,182,595,175,598) +ct(168,601,161,602,154,602) +ct(140,602,130,596,123,584) +ct(119,578,114,562,109,535) + )cp +endchar; + +beginchar(153,556*FX#,875*FY#,15*FY#); +"Scaron"; +dr +ah((457,677) +lt(457,448) +lt(439,448) +ct(433,492,423,527,407,553) +ct(392,579,371,599,343,615) +ct(315,630,286,638,256,638) +ct(222,638,194,627,172,607) +ct(150,586,139,562,139,536) +ct(139,516,146,497,160,481) +ct(180,456,228,423,304,383) +ct(366,350,408,325,430,307) +ct(453,289,470,268,483,244) +ct(495,220,501,195,501,168) +ct(501,118,482,75,443,39) +ct(404,3,354,-15,292,-15) +ct(273,-15,255,-13,238,-10) +ct(228,-9,207,-3,176,7) +ct(144,17,124,22,115,22) +ct(107,22,101,20,96,15) +ct(91,10,88,0,85,-15) +lt(67,-15) +lt(67,211) +lt(85,211) +ct(94,164,105,128,120,105) +ct(134,81,156,62,185,46) +ct(215,30,247,22,282,22) +ct(323,22,355,33,379,55) +ct(402,76,414,102,414,131) +ct(414,147,410,164,401,180) +ct(392,197,378,212,359,227) +ct(346,236,312,257,255,289) +ct(198,321,158,346,134,365) +ct(110,384,92,404,80,427) +ct(67,450,61,475,61,502) +ct(61,550,79,591,116,625) +ct(152,660,199,677,255,677) +ct(290,677,327,668,367,651) +ct(385,643,397,639,405,639) +ct(414,639,421,641,426,646) +ct(431,651,436,661,439,677) +lt(457,677) + )cp +dr +ah((320,713) +lt(230,713) +lt(138,875) +lt(153,875) +lt(286,771) +lt(398,875) +lt(413,875) +lt(320,713) + )cp +endchar; + +beginchar(156,389*FX#,676*FY#,13*FY#); +"scaron"; +dr +ah((320,460) +lt(320,308) +lt(304,308) +ct(291,355,275,388,256,405) +ct(237,423,212,431,182,431) +ct(159,431,141,425,127,413) +ct(113,401,106,388,106,373) +ct(106,355,111,339,122,326) +ct(132,312,152,298,183,284) +lt(254,249) +ct(320,217,354,174,354,122) +ct(354,81,338,48,307,23) +ct(277,-1,242,-13,204,-13) +ct(176,-13,145,-8,110,0) +ct(99,3,90,5,84,5) +ct(76,5,70,1,66,-6) +lt(50,-6) +lt(50,152) +lt(66,152) +ct(76,107,93,72,119,49) +ct(144,26,173,15,205,15) +ct(228,15,246,21,260,34) +ct(274,48,281,63,281,82) +ct(281,104,273,123,258,139) +ct(242,154,210,173,163,197) +ct(116,220,85,241,70,260) +ct(55,278,48,302,48,331) +ct(48,367,61,398,86,423) +ct(111,448,144,460,184,460) +ct(201,460,222,456,248,449) +ct(264,443,275,441,281,441) +ct(286,441,291,443,293,445) +ct(296,447,300,452,304,460) +lt(320,460) + )cp +dr +ah((239,514) +lt(149,514) +lt(57,676) +lt(72,676) +lt(205,572) +lt(317,676) +lt(332,676) +lt(239,514) + )cp +endchar; + +beginchar(218,722*FX#,877*FY#,15*FY#); +"Uacute"; +dr +ah((477,644) +lt(477,662) +lt(711,662) +lt(711,644) +lt(686,644) +ct(660,644,640,633,626,611) +ct(619,601,616,577,616,541) +lt(616,272) +ct(616,206,609,154,596,117) +ct(583,81,557,49,518,23) +ct(480,-2,427,-15,361,-15) +ct(289,-15,234,-3,196,21) +ct(159,47,132,80,117,123) +ct(106,151,101,206,101,286) +lt(101,544) +ct(101,585,95,612,84,625) +ct(73,637,55,644,30,644) +lt(5,644) +lt(5,662) +lt(291,662) +lt(291,644) +lt(266,644) +ct(238,644,219,635,207,618) +ct(199,606,195,581,195,544) +lt(195,256) +ct(195,230,197,201,202,167) +ct(207,134,215,108,228,90) +ct(240,71,258,56,281,44) +ct(304,32,333,26,367,26) +ct(410,26,449,35,483,54) +ct(517,73,540,97,553,127) +ct(565,156,572,206,572,276) +lt(572,544) +ct(572,585,567,611,558,622) +ct(545,636,526,644,501,644) +lt(477,644) + )cp +dr +ah((468,877) +lt(324,708) +lt(308,708) +lt(359,877) +lt(468,877) + )cp +endchar; + +beginchar(154,722*FX#,833*FY#,0*FY#); +"Ydieresis"; +dr +ah((476,662) +lt(707,662) +lt(707,644) +lt(694,644) +ct(686,644,673,640,657,632) +ct(641,625,626,614,613,600) +ct(599,586,583,563,563,532) +lt(404,280) +lt(404,114) +ct(404,73,408,48,417,38) +ct(429,24,449,18,476,18) +lt(498,18) +lt(498,0) +lt(216,0) +lt(216,18) +lt(240,18) +ct(268,18,287,26,299,43) +ct(306,53,310,77,310,114) +lt(310,271) +lt(128,548) +ct(107,581,92,601,85,609) +ct(77,618,61,627,37,639) +ct(30,642,21,644,9,644) +lt(9,662) +lt(292,662) +lt(292,644) +lt(277,644) +ct(262,644,248,640,235,633) +ct(222,626,216,615,216,601) +ct(216,589,226,567,246,537) +lt(384,324) +lt(514,528) +ct(533,558,543,581,543,596) +ct(543,605,541,613,536,621) +ct(531,628,524,633,516,637) +ct(507,642,494,644,476,644) +lt(476,662) + )cp +dr +ah((457,833) +ct(471,833,484,828,494,818) +ct(504,807,509,795,509,780) +ct(509,766,504,753,494,743) +ct(484,733,471,728,457,728) +ct(442,728,429,733,419,743) +ct(409,753,403,766,403,780) +ct(403,795,409,807,419,818) +ct(429,828,442,833,457,833) + )cp +dr +ah((284,833) +ct(299,833,312,828,322,818) +ct(332,807,337,795,337,780) +ct(337,766,332,753,322,743) +ct(311,733,299,728,285,728) +ct(270,728,257,733,247,743) +ct(237,753,231,766,231,780) +ct(231,795,237,807,247,818) +ct(257,828,270,833,284,833) + )cp +endchar; + +beginchar(255,500*FX#,652*FY#,215*FY#); +"ydieresis"; +dr +ah((5,447) +lt(214,447) +lt(214,429) +lt(204,429) +ct(189,429,178,426,171,419) +ct(163,413,160,405,160,395) +ct(160,382,165,365,176,343) +lt(285,117) +lt(385,364) +ct(390,377,393,390,393,404) +ct(393,410,392,414,390,417) +ct(387,421,383,423,377,426) +ct(372,428,362,429,348,429) +lt(348,447) +lt(494,447) +lt(494,429) +ct(482,427,472,425,466,421) +ct(459,417,452,410,444,399) +ct(441,394,436,381,428,361) +lt(246,-84) +ct(228,-127,205,-160,177,-182) +ct(148,-204,121,-215,94,-215) +ct(75,-215,59,-210,47,-199) +ct(34,-188,28,-175,28,-161) +ct(28,-147,33,-136,42,-128) +ct(51,-119,63,-115,79,-115) +ct(89,-115,104,-118,123,-126) +ct(135,-130,143,-133,147,-133) +ct(157,-133,167,-128,179,-118) +ct(190,-108,202,-89,214,-60) +lt(246,17) +lt(85,354) +ct(80,364,72,377,62,392) +ct(53,403,46,411,41,415) +ct(33,420,21,425,5,429) +lt(5,447) + )cp +dr +ah((354,652) +ct(368,652,381,647,391,637) +ct(401,626,406,614,406,599) +ct(406,584,401,572,391,562) +ct(381,552,368,546,354,546) +ct(339,546,326,552,316,562) +ct(305,572,300,584,300,599) +ct(300,614,305,626,316,637) +ct(326,647,339,652,354,652) + )cp +dr +ah((181,652) +ct(196,652,209,647,219,637) +ct(229,626,234,614,234,599) +ct(234,584,229,572,219,562) +ct(208,552,196,546,182,546) +ct(167,546,154,552,144,562) +ct(134,572,128,584,128,599) +ct(128,614,134,626,144,637) +ct(154,647,166,652,181,652) + )cp +endchar; + +beginchar(30,889*FX#,667*FY#,7*FY#); +"OE"; +dr +ah((539,625) +lt(539,364) +lt(628,364) +ct(665,364,692,372,708,387) +ct(723,403,731,427,730,460) +lt(750,460) +lt(750,229) +lt(730,229) +ct(728,270,719,296,706,309) +ct(692,322,666,328,628,328) +lt(539,328) +lt(539,109) +ct(539,83,540,66,543,59) +ct(547,51,552,45,560,41) +ct(564,38,577,37,597,37) +lt(648,37) +ct(687,37,714,39,730,43) +ct(745,47,761,57,778,72) +ct(802,94,823,125,841,166) +lt(860,166) +lt(808,0) +lt(571,0) +ct(525,0,497,0,487,0) +ct(483,0,456,-1,406,-4) +ct(370,-6,347,-7,335,-7) +ct(280,-7,230,6,184,33) +ct(139,61,103,102,76,156) +ct(49,209,36,267,36,330) +ct(36,414,59,488,105,552) +ct(159,628,240,667,346,667) +ct(353,667,384,666,440,664) +ct(486,662,529,662,571,662) +lt(802,662) +lt(808,516) +lt(792,516) +ct(784,554,777,579,771,589) +ct(763,601,750,611,733,619) +ct(722,623,699,625,664,625) +lt(539,625) + )cp +dr +ah((445,508) +ct(445,551,442,579,436,592) +ct(430,606,421,616,410,622) +ct(393,631,372,636,348,636) +ct(307,636,272,624,241,601) +ct(210,577,187,540,172,491) +ct(156,442,148,387,148,326) +ct(148,275,155,226,169,179) +ct(183,131,205,94,235,67) +ct(266,40,302,26,346,26) +ct(370,26,390,31,405,39) +ct(420,47,431,59,436,74) +ct(442,89,445,119,445,166) +lt(445,508) + )cp +endchar; + +beginchar(27,722*FX#,460*FY#,13*FY#); +"oe"; +dr +ah((421,279) +ct(420,271,420,265,420,261) +ct(420,230,425,198,436,165) +ct(447,132,463,107,485,91) +ct(506,75,530,66,556,66) +ct(582,66,605,75,625,91) +ct(645,108,661,135,672,173) +lt(688,165) +ct(677,102,656,56,627,28) +ct(598,0,563,-13,522,-13) +ct(491,-13,464,-6,442,9) +ct(419,24,402,43,391,64) +ct(371,38,348,19,322,6) +ct(296,-7,267,-13,236,-13) +ct(179,-13,130,7,91,49) +ct(52,90,32,146,32,216) +ct(32,290,52,350,93,394) +ct(133,438,181,460,239,460) +ct(274,460,304,453,330,438) +ct(355,424,376,406,391,383) +ct(410,410,430,430,452,442) +ct(473,454,499,460,529,460) +ct(577,460,616,444,646,412) +ct(676,380,690,335,688,279) +lt(421,279) + )cp +dr +ah((221,433) +ct(209,433,195,429,179,420) +ct(163,412,150,397,142,376) +ct(130,348,124,311,124,263) +ct(124,179,140,112,173,64) +ct(193,34,218,20,248,20) +ct(277,20,301,33,320,57) +ct(339,81,349,123,349,184) +ct(349,260,338,320,316,365) +ct(294,411,262,433,221,433) + )cp +dr +ah((421,311) +lt(592,311) +ct(592,333,589,355,581,376) +ct(575,392,565,405,551,414) +ct(537,423,522,428,507,428) +ct(485,428,466,418,449,398) +ct(432,379,423,350,421,311) + )cp +endchar; + +beginchar(182,453*FX#,662*FY#,215*FY#); +"paragraph"; +dr +ah((389,635) +lt(389,-215) +lt(354,-215) +lt(354,635) +lt(263,635) +lt(263,-215) +lt(227,-215) +lt(227,293) +ct(165,296,118,304,88,318) +ct(57,331,33,353,17,382) +ct(1,410,-6,443,-6,479) +ct(-6,514,0,543,14,566) +ct(33,598,58,621,89,637) +ct(121,654,162,662,212,662) +lt(454,662) +lt(454,635) +lt(389,635) + )cp +endchar; + +beginchar(139,500*FX#,685*FY#,205*FY#); +"dagger"; +dr +ah((255,-205) +lt(237,-205) +ct(235,-63,230,50,222,137) +ct(214,201,203,263,188,321) +ct(205,336,216,351,224,367) +ct(231,383,235,406,237,437) +ct(216,435,195,429,173,420) +ct(139,405,114,398,98,398) +ct(83,398,72,403,62,412) +ct(53,420,49,431,49,445) +ct(49,458,54,470,63,479) +ct(73,489,85,493,99,493) +ct(107,493,114,492,122,490) +ct(125,489,142,482,173,469) +ct(192,460,213,455,237,454) +ct(237,467,236,477,234,484) +ct(231,494,226,508,219,526) +ct(201,568,193,599,193,621) +ct(193,640,198,655,209,667) +ct(220,679,233,685,248,685) +ct(261,685,274,678,284,666) +ct(295,654,301,639,301,621) +ct(301,611,299,601,297,592) +ct(294,579,286,559,275,531) +ct(263,502,257,477,255,454) +ct(278,456,300,461,320,469) +ct(352,481,370,488,376,490) +ct(383,492,390,493,398,493) +ct(414,493,426,488,436,479) +ct(445,470,450,458,450,445) +ct(450,432,445,421,436,412) +ct(426,402,414,398,400,398) +ct(382,398,355,405,319,421) +ct(304,427,292,431,286,433) +ct(279,435,269,436,255,437) +ct(257,406,261,383,269,366) +ct(276,350,288,335,304,321) +ct(289,262,278,203,271,144) +ct(265,85,260,-31,255,-205) + )cp +endchar; + +beginchar(140,500*FX#,694*FY#,215*FY#); +"daggerdbl"; +dr +ah((258,476) +ct(261,455,265,439,271,428) +ct(277,418,288,406,304,393) +ct(288,369,276,346,269,323) +ct(262,300,258,271,258,236) +ct(258,203,262,176,269,154) +ct(275,131,287,108,304,83) +ct(289,69,278,57,272,47) +ct(266,36,261,20,258,0) +ct(271,1,280,3,286,5) +ct(292,6,303,11,321,18) +ct(348,29,370,35,386,35) +ct(400,35,410,31,419,23) +ct(427,15,432,5,432,-7) +ct(432,-20,427,-31,419,-39) +ct(410,-48,400,-52,387,-52) +ct(373,-52,353,-46,325,-34) +ct(309,-27,297,-23,289,-21) +ct(281,-19,271,-18,258,-18) +ct(261,-37,263,-51,265,-57) +ct(266,-63,270,-72,275,-84) +ct(291,-120,299,-146,299,-164) +ct(299,-179,295,-191,285,-201) +ct(276,-210,264,-215,250,-215) +ct(236,-215,225,-210,215,-200) +ct(206,-190,201,-178,201,-163) +ct(201,-155,202,-147,204,-138) +ct(206,-130,213,-111,224,-83) +ct(231,-61,236,-40,239,-18) +ct(224,-18,213,-20,204,-21) +ct(196,-23,184,-28,168,-35) +ct(143,-46,125,-52,113,-52) +ct(99,-52,89,-48,81,-40) +ct(72,-32,68,-21,68,-9) +ct(68,4,73,14,81,23) +ct(90,31,101,35,115,35) +ct(128,35,146,30,170,20) +ct(186,12,198,8,208,6) +ct(214,4,225,3,239,3) +ct(236,23,231,38,225,48) +ct(219,58,208,70,192,83) +ct(206,102,217,121,224,141) +ct(234,171,239,204,239,242) +ct(239,280,234,313,224,342) +ct(217,359,206,376,192,393) +ct(208,405,218,416,224,427) +ct(230,437,235,454,239,476) +ct(225,475,216,474,210,472) +ct(204,471,190,466,168,457) +ct(145,448,126,443,110,443) +ct(98,443,88,447,80,456) +ct(71,464,67,474,67,486) +ct(67,498,71,508,79,516) +ct(87,524,97,528,110,528) +ct(124,528,146,522,174,512) +ct(190,504,203,500,211,499) +ct(217,497,226,495,239,495) +ct(238,509,237,519,235,525) +ct(231,538,223,559,213,588) +ct(206,605,202,615,202,618) +ct(200,623,200,630,200,640) +ct(200,656,204,669,214,679) +ct(223,689,235,694,249,694) +ct(263,694,274,689,283,680) +ct(292,670,296,656,296,638) +ct(296,628,295,619,294,613) +ct(292,606,286,592,276,569) +ct(266,546,260,521,258,495) +ct(273,496,283,497,289,498) +ct(295,500,308,504,326,512) +ct(350,522,371,528,388,528) +ct(401,528,411,524,419,516) +ct(428,508,432,498,432,486) +ct(432,473,427,463,419,455) +ct(410,446,399,442,386,442) +ct(370,442,350,447,324,458) +ct(308,466,296,471,290,472) +ct(283,474,273,475,258,476) + )cp +endchar; + +beginchar(124,1000*FX#,257*FY#,0*FY#); +"emdash"; +dr +ah((1008,221) +lt(-9,221) +lt(-9,257) +lt(1008,257) +lt(1008,221) + )cp +endchar; + +beginchar(170,275*FX#,675*FY#,0*FY#); +"ordfeminine"; +dr +ah((166,576) +ct(166,611,161,634,153,645) +ct(144,656,131,662,114,662) +ct(98,662,87,658,79,651) +ct(72,644,68,633,68,618) +ct(68,604,65,593,60,586) +ct(54,579,48,576,40,576) +ct(32,576,26,579,20,584) +ct(15,590,12,597,12,605) +ct(12,623,21,639,40,654) +ct(58,668,87,675,126,675) +ct(156,675,179,670,196,660) +ct(212,650,222,640,226,629) +ct(231,618,233,600,233,576) +lt(233,469) +ct(233,451,233,441,234,439) +ct(234,435,236,432,239,430) +ct(241,428,244,427,246,427) +ct(250,427,259,431,274,441) +lt(274,418) +ct(250,401,234,390,226,387) +ct(218,384,210,382,201,382) +ct(193,382,186,385,179,392) +ct(173,399,168,411,166,428) +ct(145,414,126,402,108,395) +ct(91,388,75,384,61,384) +ct(43,384,28,390,16,402) +ct(3,415,-2,429,-2,444) +ct(-2,458,1,471,7,482) +ct(17,496,34,511,60,527) +ct(76,537,112,553,166,576) + )cp +dr +ah((166,557) +ct(126,544,100,530,86,514) +ct(72,499,64,483,64,467) +ct(64,456,69,446,77,438) +ct(85,430,96,425,108,425) +ct(115,425,123,427,133,431) +ct(143,434,153,440,166,447) +lt(166,557) + )cp +endchar; + +beginchar(186,310*FX#,675*FY#,0*FY#); +"ordmasculine"; +dr +ah((158,675) +ct(198,675,232,662,258,634) +ct(285,607,298,573,298,532) +ct(298,492,283,457,254,428) +ct(225,398,191,384,151,384) +ct(113,384,80,397,54,424) +ct(27,450,14,484,14,524) +ct(14,569,27,606,54,634) +ct(81,661,115,675,158,675) + )cp +dr +ah((144,654) +ct(127,654,113,647,101,632) +ct(89,618,83,594,83,562) +ct(83,510,94,469,116,437) +ct(128,418,145,409,166,409) +ct(185,409,200,416,212,430) +ct(224,445,230,468,230,499) +ct(230,550,218,592,196,624) +ct(181,644,164,654,144,654) + )cp +endchar; + +beginchar(171,500*FX#,456*FY#,3*FY#); +"guillemotleft"; +dr +ah((248,-3) +lt(220,-3) +lt(31,226) +lt(220,456) +lt(248,456) +lt(128,226) +lt(248,-3) + )cp +dr +ah((468,-3) +lt(440,-3) +lt(248,226) +lt(440,456) +lt(468,456) +lt(350,226) +lt(468,-3) + )cp +endchar; + +beginchar(187,500*FX#,456*FY#,3*FY#); +"guillemotright"; +dr +ah((251,456) +lt(279,456) +lt(468,225) +lt(279,-3) +lt(251,-3) +lt(371,225) +lt(251,456) + )cp +dr +ah((31,456) +lt(59,456) +lt(251,225) +lt(59,-3) +lt(31,-3) +lt(149,225) +lt(31,456) + )cp +endchar; + +beginchar(145,1000*FX#,94*FY#,13*FY#); +"ellipsis"; +dr +ah((166,94) +ct(181,94,194,89,205,78) +ct(215,68,220,55,220,40) +ct(220,25,215,12,204,2) +ct(194,-8,181,-13,166,-13) +ct(151,-13,138,-8,128,2) +ct(117,12,112,25,112,40) +ct(112,55,117,68,128,79) +ct(138,89,151,94,166,94) + )cp +dr +ah((500,94) +ct(514,94,527,89,538,78) +ct(548,68,554,55,554,40) +ct(554,25,548,12,538,2) +ct(527,-8,514,-13,500,-13) +ct(485,-13,472,-8,461,2) +ct(451,12,445,25,445,40) +ct(445,55,451,68,461,79) +ct(472,89,485,94,500,94) + )cp +dr +ah((833,94) +ct(848,94,861,89,871,78) +ct(882,68,887,55,887,40) +ct(887,25,882,12,871,2) +ct(861,-8,848,-13,833,-13) +ct(818,-13,805,-8,795,2) +ct(784,12,779,25,779,40) +ct(779,55,784,68,794,79) +ct(805,89,818,94,833,94) + )cp +endchar; + +beginchar(166,200*FX#,694*FY#,215*FY#); +"brokenbar"; +dr +ah((119,694) +lt(119,332) +lt(78,332) +lt(78,694) +lt(119,694) + )cp +dr +ah((119,146) +lt(119,-215) +lt(78,-215) +lt(78,146) +lt(119,146) + )cp +endchar; + +beginchar(172,563*FX#,428*FY#,0*FY#); +"logicalnot"; +dr +ah((17,428) +lt(544,428) +lt(544,230) +lt(506,230) +lt(506,389) +lt(17,389) +lt(17,428) + )cp +endchar; + +beginchar(173,1*FX#,0*FY#,0*FY#); +"minus"; +endchar; + +beginchar(176,399*FX#,676*FY#,0*FY#); +"degree"; +dr +ah((197,676) +ct(239,676,275,662,304,632) +ct(333,603,348,568,348,526) +ct(348,485,333,449,304,420) +ct(274,391,239,376,197,376) +ct(156,376,121,391,91,420) +ct(62,449,47,485,47,526) +ct(47,568,62,603,91,632) +ct(120,662,156,676,197,676) + )cp +dr +ah((197,635) +ct(167,635,141,625,120,604) +ct(99,582,88,557,88,526) +ct(88,496,99,471,120,449) +ct(141,428,167,417,197,417) +ct(227,417,253,428,274,449) +ct(295,471,306,496,306,526) +ct(306,557,296,582,274,604) +ct(253,625,228,635,197,635) + )cp +endchar; + +beginchar(178,299*FX#,675*FY#,0*FY#); +"twosuperior"; +dr +ah((280,398) +lt(250,324) +lt(9,324) +lt(9,338) +ct(89,400,143,451,169,491) +ct(185,515,194,538,194,561) +ct(194,580,187,597,174,611) +ct(160,624,143,631,123,631) +ct(104,631,88,626,74,616) +ct(60,607,49,592,42,573) +lt(20,573) +ct(25,605,37,630,58,648) +ct(79,666,105,675,138,675) +ct(173,675,201,666,222,647) +ct(244,628,255,607,255,583) +ct(255,561,247,539,231,515) +ct(207,477,159,429,87,371) +lt(178,371) +ct(207,371,225,373,235,376) +ct(244,380,252,388,258,398) +lt(280,398) + )cp +endchar; + +beginchar(179,299*FX#,675*FY#,0*FY#); +"threesuperior"; +dr +ah((26,600) +ct(38,624,51,641,66,652) +ct(86,667,111,675,139,675) +ct(169,675,192,668,209,653) +ct(227,638,235,621,235,604) +ct(235,581,218,556,184,528) +ct(208,519,225,507,237,491) +ct(249,476,255,458,255,439) +ct(255,405,241,377,213,353) +ct(185,328,145,316,93,316) +ct(65,316,46,320,34,328) +ct(25,333,21,339,21,347) +ct(21,353,24,358,29,362) +ct(34,367,41,369,50,369) +ct(59,369,72,365,89,357) +ct(107,350,121,346,134,346) +ct(152,346,168,352,181,365) +ct(194,378,200,393,200,410) +ct(200,425,196,439,187,452) +ct(179,465,167,475,154,480) +ct(134,487,117,491,102,491) +lt(87,491) +lt(87,505) +ct(112,505,133,513,150,528) +ct(167,543,176,561,176,581) +ct(176,597,170,610,160,620) +ct(149,630,135,635,117,635) +ct(89,635,65,620,45,592) +lt(26,600) + )cp +endchar; + +beginchar(185,299*FX#,675*FY#,0*FY#); +"onesuperior"; +dr +ah((66,633) +lt(166,675) +lt(183,675) +lt(183,386) +ct(183,366,184,354,186,350) +ct(187,347,190,345,194,343) +ct(199,340,212,339,232,339) +lt(232,324) +lt(74,324) +lt(74,339) +ct(94,339,107,340,113,343) +ct(117,344,119,347,121,351) +ct(123,354,124,366,124,386) +lt(124,569) +ct(124,592,123,607,121,615) +ct(120,620,118,624,116,626) +ct(114,628,110,629,106,629) +ct(100,629,89,625,74,619) +lt(66,633) + )cp +endchar; + +beginchar(188,750*FX#,675*FY#,26*FY#); +"onequarter"; +dr +ah((65,633) +lt(165,675) +lt(182,675) +lt(182,386) +ct(182,366,183,354,185,350) +ct(186,347,189,345,193,343) +ct(198,340,211,339,231,339) +lt(231,324) +lt(73,324) +lt(73,339) +ct(93,339,106,340,112,343) +ct(116,344,118,347,120,351) +ct(122,354,123,366,123,386) +lt(123,569) +ct(123,592,122,607,120,615) +ct(119,620,117,624,115,626) +ct(113,628,109,629,105,629) +ct(99,629,88,625,73,619) +lt(65,633) + )cp +dr +ah((630,675) +lt(174,-26) +lt(130,-26) +lt(587,675) +lt(630,675) + )cp +dr +ah((732,109) +lt(732,69) +lt(680,69) +lt(680,-19) +lt(623,-19) +lt(623,69) +lt(455,69) +lt(455,105) +lt(639,332) +lt(680,332) +lt(680,109) +lt(732,109) + )cp +dr +ah((623,109) +lt(623,263) +lt(496,109) +lt(623,109) + )cp +endchar; + +beginchar(190,750*FX#,675*FY#,26*FY#); +"threequarters"; +dr +ah((623,675) +lt(168,-26) +lt(125,-26) +lt(581,675) +lt(623,675) + )cp +dr +ah((25,600) +ct(37,624,50,641,65,652) +ct(85,667,110,675,138,675) +ct(168,675,191,668,208,653) +ct(226,638,234,621,234,604) +ct(234,581,217,556,183,528) +ct(207,519,224,507,236,491) +ct(248,476,254,458,254,439) +ct(254,405,240,377,212,353) +ct(184,328,144,316,92,316) +ct(64,316,45,320,33,328) +ct(24,333,20,339,20,347) +ct(20,353,23,358,28,362) +ct(33,367,40,369,49,369) +ct(58,369,71,365,88,357) +ct(106,350,120,346,133,346) +ct(151,346,167,352,180,365) +ct(193,378,199,393,199,410) +ct(199,434,190,453,172,469) +ct(153,484,125,492,86,491) +lt(86,505) +ct(111,505,132,513,149,528) +ct(166,543,175,561,175,581) +ct(175,597,169,610,159,620) +ct(148,630,134,635,116,635) +ct(88,635,64,620,44,592) +lt(25,600) + )cp +dr +ah((732,109) +lt(732,69) +lt(680,69) +lt(680,-19) +lt(623,-19) +lt(623,69) +lt(455,69) +lt(455,105) +lt(639,332) +lt(680,332) +lt(680,109) +lt(732,109) + )cp +dr +ah((623,109) +lt(623,263) +lt(496,109) +lt(623,109) + )cp +endchar; + +beginchar(131,563*FX#,532*FY#,0*FY#); +"multiply"; +dr +ah((80,160) +lt(252,332) +lt(81,504) +lt(109,532) +lt(281,360) +lt(453,532) +lt(480,504) +lt(308,333) +lt(481,160) +lt(453,131) +lt(280,304) +lt(108,132) +lt(80,160) + )cp +endchar; + +beginchar(221,722*FX#,877*FY#,0*FY#); +"Yacute"; +dr +ah((476,662) +lt(707,662) +lt(707,644) +lt(694,644) +ct(686,644,673,640,657,632) +ct(641,625,626,614,613,600) +ct(599,586,583,563,563,532) +lt(404,280) +lt(404,114) +ct(404,73,408,48,417,38) +ct(429,24,449,18,476,18) +lt(498,18) +lt(498,0) +lt(216,0) +lt(216,18) +lt(240,18) +ct(268,18,287,26,299,43) +ct(306,53,310,77,310,114) +lt(310,271) +lt(128,548) +ct(107,581,92,601,85,609) +ct(77,618,61,627,37,639) +ct(30,642,21,644,9,644) +lt(9,662) +lt(292,662) +lt(292,644) +lt(277,644) +ct(262,644,248,640,235,633) +ct(222,626,216,615,216,601) +ct(216,589,226,567,246,537) +lt(384,324) +lt(514,528) +ct(533,558,543,581,543,596) +ct(543,605,541,613,536,621) +ct(531,628,524,633,516,637) +ct(507,642,494,644,476,644) +lt(476,662) + )cp +dr +ah((486,877) +lt(342,708) +lt(325,708) +lt(376,877) +lt(486,877) + )cp +endchar; + +beginchar(253,500*FX#,678*FY#,215*FY#); +"yacute"; +dr +ah((5,447) +lt(214,447) +lt(214,429) +lt(204,429) +ct(189,429,178,426,171,419) +ct(163,413,160,405,160,395) +ct(160,382,165,365,176,343) +lt(285,117) +lt(385,364) +ct(390,377,393,390,393,404) +ct(393,410,392,414,390,417) +ct(387,421,383,423,377,426) +ct(372,428,362,429,348,429) +lt(348,447) +lt(494,447) +lt(494,429) +ct(482,427,472,425,466,421) +ct(459,417,452,410,444,399) +ct(441,394,436,381,428,361) +lt(246,-84) +ct(228,-127,205,-160,177,-182) +ct(148,-204,121,-215,94,-215) +ct(75,-215,59,-210,47,-199) +ct(34,-188,28,-175,28,-161) +ct(28,-147,33,-136,42,-128) +ct(51,-119,63,-115,79,-115) +ct(89,-115,104,-118,123,-126) +ct(135,-130,143,-133,147,-133) +ct(157,-133,167,-128,179,-118) +ct(190,-108,202,-89,214,-60) +lt(246,17) +lt(85,354) +ct(80,364,72,377,62,392) +ct(53,403,46,411,41,415) +ct(33,420,21,425,5,429) +lt(5,447) + )cp +dr +ah((357,678) +lt(213,510) +lt(196,510) +lt(248,678) +lt(357,678) + )cp +endchar; + +beginchar(152,548*FX#,524*FY#,0*FY#); +"divide"; +dr +ah((274,524) +ct(286,524,296,520,304,512) +ct(312,504,316,494,316,482) +ct(316,470,312,460,304,452) +ct(296,444,285,439,273,439) +ct(262,439,252,444,243,452) +ct(235,460,231,470,231,482) +ct(231,494,235,504,243,512) +ct(252,520,262,524,274,524) + )cp +dr +ah((537,312) +lt(11,312) +lt(11,352) +lt(537,352) +lt(537,312) + )cp +dr +ah((274,222) +ct(286,222,296,217,304,209) +ct(313,201,317,190,317,179) +ct(317,167,313,157,304,148) +ct(296,140,286,136,274,136) +ct(262,136,252,140,244,148) +ct(235,157,231,167,231,179) +ct(231,190,235,201,243,209) +ct(252,217,262,222,274,222) + )cp +endchar; + +beginchar(248,1*FX#,0*FY#,0*FY#); +"radical"; +endchar; + +beginchar(198,1*FX#,0*FY#,0*FY#); +"greaterequal"; +endchar; + +beginchar(192,1*FX#,0*FY#,0*FY#); +"lessequal"; +endchar; + +beginchar(175,1*FX#,0*FY#,0*FY#); +"notequal"; +endchar; + +beginchar(184,1*FX#,0*FY#,0*FY#); +"infinity"; +endchar; + +beginchar(215,1*FX#,0*FY#,0*FY#); +"partialdiff"; +endchar; + +beginchar(216,1*FX#,0*FY#,0*FY#); +"summation"; +endchar; + +beginchar(1,1*FX#,0*FY#,0*FY#); +"Delta"; +endchar; + +beginchar(133,1*FX#,0*FY#,0*FY#); +"approxequal"; +endchar; + +beginchar(10,1*FX#,0*FY#,0*FY#); +"Omega"; +endchar; + +beginchar(223,1*FX#,0*FY#,0*FY#); +"product"; +endchar; + +beginchar(230,1*FX#,0*FY#,0*FY#); +"pi"; +endchar; + +beginchar(247,1*FX#,0*FY#,0*FY#); +"integral"; +endchar; + +beginchar(155,1*FX#,0*FY#,0*FY#); +"Zcaron"; +endchar; + +beginchar(157,1*FX#,0*FY#,0*FY#); +"zcaron"; +endchar; + +beginchar(160,333*FX#,97*FY#,166*FY#); +"quotesinglbase"; +dr +ah((53,-166) +lt(53,-145) +ct(87,-133,113,-116,131,-93) +ct(149,-70,159,-45,159,-19) +ct(159,-13,157,-7,154,-3) +ct(152,-1,149,0,147,0) +ct(143,0,136,-3,124,-9) +ct(118,-11,111,-13,105,-13) +ct(90,-13,77,-8,67,0) +ct(58,9,53,22,53,39) +ct(53,55,59,69,72,80) +ct(84,91,99,97,116,97) +ct(138,97,157,88,174,69) +ct(190,50,199,26,199,-4) +ct(199,-38,187,-69,164,-98) +ct(141,-127,104,-149,53,-166) + )cp +endchar; + +beginchar(0,1*FX#,0*FY#,0*FY#); +"Gamma"; +endchar; + +beginchar(2,1*FX#,0*FY#,0*FY#); +"Theta"; +endchar; + +beginchar(8,1*FX#,0*FY#,0*FY#); +"Phi"; +endchar; + +beginchar(11,1*FX#,0*FY#,0*FY#); +"ff"; +endchar; + +beginchar(14,1*FX#,0*FY#,0*FY#); +"ffi"; +endchar; + +beginchar(15,1*FX#,0*FY#,0*FY#); +"ffl"; +endchar; +endchar; + +ligtable 123: +45=:124; + +ligtable 121: +46 kern -64FX#, +44 kern -64FX#; + +ligtable 119: +46 kern -64FX#, +44 kern -64FX#; + +ligtable 118: +46 kern -64FX#, +44 kern -64FX#; + +ligtable 114: +39 kern 37FX#, +103 kern -18FX#, +46 kern -55FX#, +45 kern -20FX#, +44 kern -40FX#; + +ligtable 102: +105=:12; + +ligtable 96: +96=:92; + +ligtable 89: +118 kern -100FX#, +117 kern -110FX#, +113 kern -110FX#, +112 kern -91FX#, +111 kern -100FX#, +105 kern -55FX#, +101 kern -100FX#, +97 kern -100FX#, +65 kern -110FX#, +59 kern -91FX#, +58 kern -91FX#, +46 kern -128FX#, +45 kern -110FX#, +44 kern -128FX#; + +ligtable 87: +121 kern -60FX#, +117 kern -40FX#, +114 kern -40FX#, +111 kern -80FX#, +105 kern -40FX#, +101 kern -80FX#, +97 kern -80FX#, +65 kern -110FX#, +59 kern -37FX#, +58 kern -37FX#, +46 kern -91FX#, +45 kern -55FX#, +44 kern -91FX#; + +ligtable 86: +121 kern -110FX#, +117 kern -60FX#, +114 kern -60FX#, +111 kern -128FX#, +105 kern -60FX#, +101 kern -110FX#, +97 kern -110FX#, +65 kern -128FX#, +59 kern -74FX#, +58 kern -74FX#, +46 kern -128FX#, +45 kern -91FX#, +44 kern -128FX#; + +ligtable 84: +121 kern -69FX#, +119 kern -69FX#, +117 kern -35FX#, +115 kern -69FX#, +114 kern -35FX#, +111 kern -69FX#, +105 kern -35FX#, +101 kern -69FX#, +99 kern -69FX#, +97 kern -69FX#, +79 kern -18FX#, +65 kern -80FX#, +59 kern -55FX#, +58 kern -49FX#, +46 kern -74FX#, +45 kern -91FX#, +44 kern -74FX#; + +ligtable 82: +121 kern -40FX#, +89 kern -55FX#, +87 kern -55FX#, +86 kern -80FX#, +84 kern -60FX#; + +ligtable 80: +65 kern -91FX#, +46 kern -110FX#, +44 kern -110FX#; + +ligtable 76: +39 kern -91FX#, +121 kern -55FX#, +89 kern -100FX#, +87 kern -74FX#, +86 kern -91FX#, +84 kern -91FX#; + +ligtable 70: +65 kern -74FX#, +46 kern -80FX#, +44 kern -80FX#; + +ligtable 65: +39 kern -110FX#, +121 kern -91FX#, +119 kern -91FX#, +118 kern -74FX#, +89 kern -91FX#, +87 kern -80FX#, +86 kern -128FX#, +84 kern -110FX#; + +ligtable 63: +96=:62; + +ligtable 45: +45=:123; + +ligtable 39: +39=:34; + +ligtable 33: +96=:60; + +font_slant := 0.0000; +font_normal_space := 250 * FX#; +font_normal_stretch := 125 * FX#; +font_normal_shrink := 83 * FX#; +font_x_height := 447 * FY#; +font_quad := 889 * FX#; +designsize := FontSize; +font_coding_scheme := "TeX text"; +font_identifier := "TimesNewRoman"; +end. +% That's all, Folks! diff --git a/fonts/utilities/ps2mf/xmalloc.c b/fonts/utilities/ps2mf/xmalloc.c new file mode 100644 index 0000000000..e9d1480325 --- /dev/null +++ b/fonts/utilities/ps2mf/xmalloc.c @@ -0,0 +1,60 @@ +/* xmalloc.c - get memory or bust + Copyright (C) 1987 Free Software Foundation, Inc. + +This file is part of GAS, the GNU Assembler. + +GAS is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GAS is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GAS; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* +NAME + xmalloc() - get memory or bust +INDEX + xmalloc() uses malloc() + +SYNOPSIS + char * my_memory; + + my_memory = xmalloc(42); / * my_memory gets address of 42 chars * / + +DESCRIPTION + + Use xmalloc() as an "error-free" malloc(). It does almost the same job. + When it cannot honour your request for memory it BOMBS your program + with a "virtual memory exceeded" message. Malloc() returns NULL and + does not bomb your program. + +SEE ALSO + malloc() + +*/ +#ifndef AIX +# include <stdlib.h> +#endif + +char * xmalloc(n) + long n; +{ + char * retval; + char * malloc(); + void error(); + + if ( ! (retval = malloc ((unsigned)n)) ) + { + error("virtual memory exceeded"); + } + return (retval); +} + +/* end: xmalloc.c */ |