diff --git a/source/libs/README b/source/libs/README
index 70735c67f..7f3a7943c 100644
--- a/source/libs/README
+++ b/source/libs/README
@@ -28,7 +28,7 @@ graphite2 1.3.14 - checked 10apr20
   https://sourceforge.net/projects/silgraphite/files/graphite2/
   (requires C++11)
 
-harfbuzz 8.4.0 - checked 30mar24
+harfbuzz 8.5.0 - checked 14may24
   https://github.com/harfbuzz/harfbuzz/releases/latest
 
 icu 74.2 - checked 22dec23
diff --git a/source/texk/dvipdfm-x/ChangeLog b/source/texk/dvipdfm-x/ChangeLog
index eb1e179b1..178ae0931 100644
--- a/source/texk/dvipdfm-x/ChangeLog
+++ b/source/texk/dvipdfm-x/ChangeLog
@@ -1,3 +1,11 @@
+2024-05-18  TANAKA Takuji  <ttk@t-lab.opal.ne.jp>
+
+	* dvi.c: Remove obsolete comments.
+	* dvipdfmx-upjf3.test, tests/upj{f,v}4_full.{vf,zvp0},
+	tests/upjf-ipa.map, tests/Makefile_upjf, Makefile.am: Add
+	a test for upTeX new encoding. It requires IPA MJ Mincho font.
+	https://github.com/texjporg/tex-jp-build/issues/46
+
 2024-05-11  TANAKA Takuji  <ttk@t-lab.opal.ne.jp>
 
 	* dvi.c: Ensure enc_name "UTF16" prior to encoding conversion
diff --git a/source/texk/dvipdfm-x/Makefile.am b/source/texk/dvipdfm-x/Makefile.am
index 884a88cd2..62ad37442 100644
--- a/source/texk/dvipdfm-x/Makefile.am
+++ b/source/texk/dvipdfm-x/Makefile.am
@@ -319,9 +319,11 @@ DISTCLEANFILES += upjf2_*.pdf
 ## dvipdfmx-upjf3.test
 EXTRA_DIST += tests/upjf3_full.zvp0 tests/upjf3_full.vf
 EXTRA_DIST += tests/upjv3_full.zvp0 tests/upjv3_full.vf
+EXTRA_DIST += tests/upjf4_full.zvp0 tests/upjf4_full.vf
+EXTRA_DIST += tests/upjv4_full.zvp0 tests/upjv4_full.vf
 EXTRA_DIST += tests/upjf-hu.tfm tests/upjf-hi.tfm
 EXTRA_DIST += tests/upjv-hu.tfm tests/upjv-hi.tfm
-EXTRA_DIST += tests/upjf-noto.map
+EXTRA_DIST += tests/upjf-noto.map tests/upjf-ipa.map
 DISTCLEANFILES += upjf3_*.pdf
 ## dvipdfmx-incl.test
 EXTRA_DIST += tests/multi_incl.dvi tests/multi_incl.tex tests/sue-mp.pdf
diff --git a/source/texk/dvipdfm-x/Makefile.in b/source/texk/dvipdfm-x/Makefile.in
index 71a55f64e..88d2d1193 100644
--- a/source/texk/dvipdfm-x/Makefile.in
+++ b/source/texk/dvipdfm-x/Makefile.in
@@ -858,10 +858,13 @@ EXTRA_DIST = $(TESTS) tests/dvipdfmx.cfg tests/psfonts.map \
 	tests/upjv2_full.zvp0 tests/upjv2_full.vf tests/upjf-c.pl \
 	tests/upjf-c.tfm tests/upjv-c.pl tests/upjv-c.tfm \
 	tests/upjf-hara.map tests/upjf3_full.zvp0 tests/upjf3_full.vf \
-	tests/upjv3_full.zvp0 tests/upjv3_full.vf tests/upjf-hu.tfm \
+	tests/upjv3_full.zvp0 tests/upjv3_full.vf \
+	tests/upjf4_full.zvp0 tests/upjf4_full.vf \
+	tests/upjv4_full.zvp0 tests/upjv4_full.vf tests/upjf-hu.tfm \
 	tests/upjf-hi.tfm tests/upjv-hu.tfm tests/upjv-hi.tfm \
-	tests/upjf-noto.map tests/multi_incl.dvi tests/multi_incl.tex \
-	tests/sue-mp.pdf tests/fullmap.dvi tests/fullmap.tex
+	tests/upjf-noto.map tests/upjf-ipa.map tests/multi_incl.dvi \
+	tests/multi_incl.tex tests/sue-mp.pdf tests/fullmap.dvi \
+	tests/fullmap.tex
 all: config.h
 	$(MAKE) $(AM_MAKEFLAGS) all-am
 
diff --git a/source/texk/dvipdfm-x/dvi.c b/source/texk/dvipdfm-x/dvi.c
index c81213569..828ea10b6 100644
--- a/source/texk/dvipdfm-x/dvi.c
+++ b/source/texk/dvipdfm-x/dvi.c
@@ -1477,7 +1477,6 @@ dvi_set (int32_t ch)
   switch (font->type) {
   case  PHYSICAL:
     if (ch > 65535) {
-      /* FIXME: uptex specific undocumented */
       if (font->is_unicode == ENC_UTF16 && tfm_is_jfm(font->tfm_id)) {
         wbuf[0] = (UTF32toUTF16HS(ch) >> 8) & 0xff;
         wbuf[1] =  UTF32toUTF16HS(ch)       & 0xff;
@@ -1563,12 +1562,11 @@ dvi_put (int32_t ch)
   switch (font->type) {
   case  PHYSICAL:
     width = tfm_get_fw_width(font->tfm_id, ch);
-    width = sqxfw(font->size, width);  
+    width = sqxfw(font->size, width);
     /* Treat a single character as a one byte string and use the
      * string routine.
-     */    
+     */
     if (ch > 65535) {
-      /* FIXME: uptex specific undocumented */
       if (font->is_unicode == ENC_UTF16 && tfm_is_jfm(font->tfm_id)) {
         wbuf[0] = (UTF32toUTF16HS(ch) >> 8) & 0xff;
         wbuf[1] =  UTF32toUTF16HS(ch)       & 0xff;
diff --git a/source/texk/dvipdfm-x/dvipdfmx-upjf3.test b/source/texk/dvipdfm-x/dvipdfmx-upjf3.test
index 4ffa17f5d..f721a0707 100755
--- a/source/texk/dvipdfm-x/dvipdfmx-upjf3.test
+++ b/source/texk/dvipdfm-x/dvipdfmx-upjf3.test
@@ -43,6 +43,18 @@ echo "*** dvipdfmx: test for upjf3_full-noto.pdf" && echo \
 	&& echo && echo "dvipdfmx-upjf3-vf_full-noto tests OK" && echo \
 	|| failed="$failed dvipdfmx-upjf3-vf_full-noto"
 
+#####  following tests require IPA MJ Mincho font  #####
+
+$_kpsewhich ipamjm.ttf || exit 77
+
+echo "*** dvipdfmx: test for upjf3_full-ipa.pdf" && echo \
+	&& cp $srcdir/tests/upjf4_full.vf ./upjf.vf \
+	&& cp $srcdir/tests/upjv4_full.vf ./upjv.vf \
+	&& $_xdvipdfmx --dvipdfmx -vv --pdfm-str-utf8 -f upjf-ipa.map -o upjf3.pdf $srcdir/tests/upjf3.dvi \
+	&& mv ./upjf3.pdf ./upjf3_full-ipa.pdf \
+	&& echo && echo "dvipdfmx-upjf3-vf_full-ipa tests OK" && echo \
+	|| failed="$failed dvipdfmx-upjf3-vf_full-ipa"
+
 
 test -z "$failed" && exit 0
 echo
diff --git a/source/texk/dvipdfm-x/tests/Makefile_upjf b/source/texk/dvipdfm-x/tests/Makefile_upjf
index 6f7854577..b3a6b9664 100644
--- a/source/texk/dvipdfm-x/tests/Makefile_upjf
+++ b/source/texk/dvipdfm-x/tests/Makefile_upjf
@@ -59,6 +59,12 @@ upjf3_full.vf: upjf3_full.zvp0
 upjv3_full.vf: upjv3_full.zvp0
 	jfmutil zvp02vf upjv3_full.zvp0
 
+upjf4_full.vf: upjf4_full.zvp0
+	jfmutil zvp02vf upjf4_full.zvp0
+
+upjv4_full.vf: upjv4_full.zvp0
+	jfmutil zvp02vf upjv4_full.zvp0
+
 upjf-c.tfm:
 	uppltotf upjf-c.pl
 
diff --git a/source/texk/dvipdfm-x/tests/upjf-ipa.map b/source/texk/dvipdfm-x/tests/upjf-ipa.map
new file mode 100644
index 000000000..6ccbfa97d
--- /dev/null
+++ b/source/texk/dvipdfm-x/tests/upjf-ipa.map
@@ -0,0 +1,12 @@
+upjf-r   unicode         ipamjm.ttf
+upjf-g   unicode         HaranoAjiGothic-Regular.otf
+upjf-c   Identity-H      HaranoAjiMincho-Regular.otf
+upjf-hu  unicode         ipamjm.ttf
+upjf-hi  Identity-H      ipamjm.ttf
+upjv-r   unicode         ipamjm.ttf -w 1
+upjv-g   unicode         HaranoAjiGothic-Regular.otf -w 1
+upjv-c   Identity-V      HaranoAjiMincho-Regular.otf
+upjv-hu  unicode         ipamjm.ttf -w 1
+upjv-hi  Identity-V      ipamjm.ttf
+
+ptmr8r 8r Times-Roman
diff --git a/source/texk/dvipdfm-x/tests/upjf4_full.vf b/source/texk/dvipdfm-x/tests/upjf4_full.vf
new file mode 100644
index 000000000..56e929fca
Binary files /dev/null and b/source/texk/dvipdfm-x/tests/upjf4_full.vf differ
diff --git a/source/texk/dvipdfm-x/tests/upjf4_full.zvp0 b/source/texk/dvipdfm-x/tests/upjf4_full.zvp0
new file mode 100644
index 000000000..eef7b59dd
--- /dev/null
+++ b/source/texk/dvipdfm-x/tests/upjf4_full.zvp0
@@ -0,0 +1,2989 @@
+(VTITLE )
+(DESIGNSIZE R 10.0)
+(CHECKSUM O 0)
+(MAPFONT D 0
+   (FONTNAME upjf-r)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 1
+   (FONTNAME upjf-g)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 2
+   (FONTNAME upjf-c)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 3
+   (FONTNAME upjf-hu)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 4
+   (FONTNAME upjf-hi)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(CHARACTER H 2600
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 2600)
+      )
+   )
+(CHARACTER H 2603
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 2603)
+      )
+   )
+(CHARACTER H 3000
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3000)
+      )
+   )
+(CHARACTER H 3001
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3001)
+      )
+   )
+(CHARACTER H 3002
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3002)
+      )
+   )
+(CHARACTER H 3003
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3003)
+      )
+   )
+(CHARACTER H 3004
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3004)
+      )
+   )
+(CHARACTER H 3005
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3005)
+      )
+   )
+(CHARACTER H 3006
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3006)
+      )
+   )
+(CHARACTER H 3007
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3007)
+      )
+   )
+(CHARACTER H 3008
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3008)
+      )
+   )
+(CHARACTER H 3009
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3009)
+      )
+   )
+(CHARACTER H 300A
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 300A)
+      )
+   )
+(CHARACTER H 300B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 300B)
+      )
+   )
+(CHARACTER H 300C
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 300C)
+      )
+   )
+(CHARACTER H 300D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 300D)
+      )
+   )
+(CHARACTER H 300E
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 300E)
+      )
+   )
+(CHARACTER H 300F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 300F)
+      )
+   )
+(CHARACTER H 3010
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3010)
+      )
+   )
+(CHARACTER H 3011
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3011)
+      )
+   )
+(CHARACTER H 3012
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3012)
+      )
+   )
+(CHARACTER H 3013
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3013)
+      )
+   )
+(CHARACTER H 3014
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3014)
+      )
+   )
+(CHARACTER H 3015
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3015)
+      )
+   )
+(CHARACTER H 3016
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3016)
+      )
+   )
+(CHARACTER H 3017
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3017)
+      )
+   )
+(CHARACTER H 3018
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3018)
+      )
+   )
+(CHARACTER H 3019
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3019)
+      )
+   )
+(CHARACTER H 301A
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 301A)
+      )
+   )
+(CHARACTER H 301B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301B)
+      )
+   )
+(CHARACTER H 301C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301C)
+      )
+   )
+(CHARACTER H 301D
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 301D)
+      )
+   )
+(CHARACTER H 301E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301E)
+      )
+   )
+(CHARACTER H 301F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301F)
+      )
+   )
+(CHARACTER H 3020
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3020)
+      )
+   )
+(CHARACTER H 3021
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3021)
+      )
+   )
+(CHARACTER H 3022
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3022)
+      )
+   )
+(CHARACTER H 3023
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3023)
+      )
+   )
+(CHARACTER H 3024
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3024)
+      )
+   )
+(CHARACTER H 3025
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3025)
+      )
+   )
+(CHARACTER H 3026
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3026)
+      )
+   )
+(CHARACTER H 3027
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3027)
+      )
+   )
+(CHARACTER H 3028
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3028)
+      )
+   )
+(CHARACTER H 3029
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3029)
+      )
+   )
+(CHARACTER H 302A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302A)
+      )
+   )
+(CHARACTER H 302B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302B)
+      )
+   )
+(CHARACTER H 302C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302C)
+      )
+   )
+(CHARACTER H 302D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302D)
+      )
+   )
+(CHARACTER H 302E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302E)
+      )
+   )
+(CHARACTER H 302F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302F)
+      )
+   )
+(CHARACTER H 3030
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3030)
+      )
+   )
+(CHARACTER H 3031
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3031)
+      )
+   )
+(CHARACTER H 3032
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3032)
+      )
+   )
+(CHARACTER H 3033
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3033)
+      )
+   )
+(CHARACTER H 3034
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3034)
+      )
+   )
+(CHARACTER H 3035
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3035)
+      )
+   )
+(CHARACTER H 3036
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3036)
+      )
+   )
+(CHARACTER H 3037
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3037)
+      )
+   )
+(CHARACTER H 3038
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3038)
+      )
+   )
+(CHARACTER H 3039
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3039)
+      )
+   )
+(CHARACTER H 303A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303A)
+      )
+   )
+(CHARACTER H 303B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303B)
+      )
+   )
+(CHARACTER H 303C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303C)
+      )
+   )
+(CHARACTER H 303D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303D)
+      )
+   )
+(CHARACTER H 303E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303E)
+      )
+   )
+(CHARACTER H 303F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303F)
+      )
+   )
+(CHARACTER H 3040
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3040)
+      )
+   )
+(CHARACTER H 3041
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3041)
+      )
+   )
+(CHARACTER H 3042
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3042)
+      )
+   )
+(CHARACTER H 3043
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3043)
+      )
+   )
+(CHARACTER H 3044
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3044)
+      )
+   )
+(CHARACTER H 3045
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3045)
+      )
+   )
+(CHARACTER H 3046
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3046)
+      )
+   )
+(CHARACTER H 3047
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3047)
+      )
+   )
+(CHARACTER H 3048
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3048)
+      )
+   )
+(CHARACTER H 3049
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3049)
+      )
+   )
+(CHARACTER H 304A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304A)
+      )
+   )
+(CHARACTER H 304B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304B)
+      )
+   )
+(CHARACTER H 304C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304C)
+      )
+   )
+(CHARACTER H 304D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304D)
+      )
+   )
+(CHARACTER H 304E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 304E)
+      )
+   )
+(CHARACTER H 304F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304F)
+      )
+   )
+(CHARACTER H 3050
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3050)
+      )
+   )
+(CHARACTER H 3051
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3051)
+      )
+   )
+(CHARACTER H 3052
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3052)
+      )
+   )
+(CHARACTER H 3053
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3053)
+      )
+   )
+(CHARACTER H 3054
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3054)
+      )
+   )
+(CHARACTER H 3055
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3055)
+      )
+   )
+(CHARACTER H 3056
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3056)
+      )
+   )
+(CHARACTER H 3057
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3057)
+      )
+   )
+(CHARACTER H 3058
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3058)
+      )
+   )
+(CHARACTER H 3059
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3059)
+      )
+   )
+(CHARACTER H 305A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305A)
+      )
+   )
+(CHARACTER H 305B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305B)
+      )
+   )
+(CHARACTER H 305C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305C)
+      )
+   )
+(CHARACTER H 305D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305D)
+      )
+   )
+(CHARACTER H 305E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305E)
+      )
+   )
+(CHARACTER H 305F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305F)
+      )
+   )
+(CHARACTER H 3060
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3060)
+      )
+   )
+(CHARACTER H 3061
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3061)
+      )
+   )
+(CHARACTER H 3062
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3062)
+      )
+   )
+(CHARACTER H 3063
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3063)
+      )
+   )
+(CHARACTER H 3064
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3064)
+      )
+   )
+(CHARACTER H 3065
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3065)
+      )
+   )
+(CHARACTER H 3066
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3066)
+      )
+   )
+(CHARACTER H 3067
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3067)
+      )
+   )
+(CHARACTER H 3068
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3068)
+      )
+   )
+(CHARACTER H 3069
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3069)
+      )
+   )
+(CHARACTER H 306A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306A)
+      )
+   )
+(CHARACTER H 306B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306B)
+      )
+   )
+(CHARACTER H 306C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306C)
+      )
+   )
+(CHARACTER H 306D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306D)
+      )
+   )
+(CHARACTER H 306E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306E)
+      )
+   )
+(CHARACTER H 306F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306F)
+      )
+   )
+(CHARACTER H 3070
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3070)
+      )
+   )
+(CHARACTER H 3071
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3071)
+      )
+   )
+(CHARACTER H 3072
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3072)
+      )
+   )
+(CHARACTER H 3073
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3073)
+      )
+   )
+(CHARACTER H 3074
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3074)
+      )
+   )
+(CHARACTER H 3075
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3075)
+      )
+   )
+(CHARACTER H 3076
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3076)
+      )
+   )
+(CHARACTER H 3077
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3077)
+      )
+   )
+(CHARACTER H 3078
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3078)
+      )
+   )
+(CHARACTER H 3079
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3079)
+      )
+   )
+(CHARACTER H 307A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307A)
+      )
+   )
+(CHARACTER H 307B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307B)
+      )
+   )
+(CHARACTER H 307C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307C)
+      )
+   )
+(CHARACTER H 307D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307D)
+      )
+   )
+(CHARACTER H 307E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307E)
+      )
+   )
+(CHARACTER H 307F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307F)
+      )
+   )
+(CHARACTER H 3080
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3080)
+      )
+   )
+(CHARACTER H 3081
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3081)
+      )
+   )
+(CHARACTER H 3082
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3082)
+      )
+   )
+(CHARACTER H 3083
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3083)
+      )
+   )
+(CHARACTER H 3084
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3084)
+      )
+   )
+(CHARACTER H 3085
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3085)
+      )
+   )
+(CHARACTER H 3086
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3086)
+      )
+   )
+(CHARACTER H 3087
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3087)
+      )
+   )
+(CHARACTER H 3088
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3088)
+      )
+   )
+(CHARACTER H 3089
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3089)
+      )
+   )
+(CHARACTER H 308A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308A)
+      )
+   )
+(CHARACTER H 308B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308B)
+      )
+   )
+(CHARACTER H 308C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308C)
+      )
+   )
+(CHARACTER H 308D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308D)
+      )
+   )
+(CHARACTER H 308E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308E)
+      )
+   )
+(CHARACTER H 308F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308F)
+      )
+   )
+(CHARACTER H 3090
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3090)
+      )
+   )
+(CHARACTER H 3091
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3091)
+      )
+   )
+(CHARACTER H 3092
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3092)
+      )
+   )
+(CHARACTER H 3093
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3093)
+      )
+   )
+(CHARACTER H 3094
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3094)
+      )
+   )
+(CHARACTER H 3095
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3095)
+      )
+   )
+(CHARACTER H 3096
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3096)
+      )
+   )
+(CHARACTER H 3097
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3097)
+      )
+   )
+(CHARACTER H 3098
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3098)
+      )
+   )
+(CHARACTER H 3099
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3099)
+      )
+   )
+(CHARACTER H 309A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309A)
+      )
+   )
+(CHARACTER H 309B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309B)
+      )
+   )
+(CHARACTER H 309C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309C)
+      )
+   )
+(CHARACTER H 309D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309D)
+      )
+   )
+(CHARACTER H 309E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309E)
+      )
+   )
+(CHARACTER H 309F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309F)
+      )
+   )
+(CHARACTER H 30FB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 30FB)
+      )
+   )
+(CHARACTER H 537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 537F)
+      )
+   )
+(CHARACTER H 6674
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 6674)
+      )
+   )
+(CHARACTER H 751F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 751F)
+      )
+   )
+(CHARACTER H 96EA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 96EA)
+      )
+   )
+(CHARACTER H FF00
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF00)
+      )
+   )
+(CHARACTER H FF01
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF01)
+      )
+   )
+(CHARACTER H FF02
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF02)
+      )
+   )
+(CHARACTER H FF03
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF03)
+      )
+   )
+(CHARACTER H FF04
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF04)
+      )
+   )
+(CHARACTER H FF05
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF05)
+      )
+   )
+(CHARACTER H FF06
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF06)
+      )
+   )
+(CHARACTER H FF07
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF07)
+      )
+   )
+(CHARACTER H FF08
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF08)
+      )
+   )
+(CHARACTER H FF09
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF09)
+      )
+   )
+(CHARACTER H FF0A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0A)
+      )
+   )
+(CHARACTER H FF0B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0B)
+      )
+   )
+(CHARACTER H FF0C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0C)
+      )
+   )
+(CHARACTER H FF0D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0D)
+      )
+   )
+(CHARACTER H FF0E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0E)
+      )
+   )
+(CHARACTER H FF0F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0F)
+      )
+   )
+(CHARACTER H FF10
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF10)
+      )
+   )
+(CHARACTER H FF11
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF11)
+      )
+   )
+(CHARACTER H FF12
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF12)
+      )
+   )
+(CHARACTER H FF13
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF13)
+      )
+   )
+(CHARACTER H FF14
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF14)
+      )
+   )
+(CHARACTER H FF15
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF15)
+      )
+   )
+(CHARACTER H FF16
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF16)
+      )
+   )
+(CHARACTER H FF17
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF17)
+      )
+   )
+(CHARACTER H FF18
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF18)
+      )
+   )
+(CHARACTER H FF19
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF19)
+      )
+   )
+(CHARACTER H FF1A
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.25)
+      (SELECTFONT D 1)
+      (SETCHAR H FF1A)
+      )
+   )
+(CHARACTER H FF1B
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.25)
+      (SELECTFONT D 1)
+      (SETCHAR H FF1B)
+      )
+   )
+(CHARACTER H FF1C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1C)
+      )
+   )
+(CHARACTER H FF1D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1D)
+      )
+   )
+(CHARACTER H FF1E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1E)
+      )
+   )
+(CHARACTER H FF1F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1F)
+      )
+   )
+(CHARACTER H FF20
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF20)
+      )
+   )
+(CHARACTER H FF21
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF21)
+      )
+   )
+(CHARACTER H FF22
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF22)
+      )
+   )
+(CHARACTER H FF23
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF23)
+      )
+   )
+(CHARACTER H FF24
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF24)
+      )
+   )
+(CHARACTER H FF25
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF25)
+      )
+   )
+(CHARACTER H FF26
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF26)
+      )
+   )
+(CHARACTER H FF27
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF27)
+      )
+   )
+(CHARACTER H FF28
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF28)
+      )
+   )
+(CHARACTER H FF29
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF29)
+      )
+   )
+(CHARACTER H FF2A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2A)
+      )
+   )
+(CHARACTER H FF2B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2B)
+      )
+   )
+(CHARACTER H FF2C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2C)
+      )
+   )
+(CHARACTER H FF2D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2D)
+      )
+   )
+(CHARACTER H FF2E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2E)
+      )
+   )
+(CHARACTER H FF2F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2F)
+      )
+   )
+(CHARACTER H FF30
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF30)
+      )
+   )
+(CHARACTER H FF31
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF31)
+      )
+   )
+(CHARACTER H FF32
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF32)
+      )
+   )
+(CHARACTER H FF33
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF33)
+      )
+   )
+(CHARACTER H FF34
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF34)
+      )
+   )
+(CHARACTER H FF35
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF35)
+      )
+   )
+(CHARACTER H FF36
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF36)
+      )
+   )
+(CHARACTER H FF37
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF37)
+      )
+   )
+(CHARACTER H FF38
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF38)
+      )
+   )
+(CHARACTER H FF39
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF39)
+      )
+   )
+(CHARACTER H FF3A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3A)
+      )
+   )
+(CHARACTER H FF3B
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF3B)
+      )
+   )
+(CHARACTER H FF3C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3C)
+      )
+   )
+(CHARACTER H FF3D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3D)
+      )
+   )
+(CHARACTER H FF3E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3E)
+      )
+   )
+(CHARACTER H FF3F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3F)
+      )
+   )
+(CHARACTER H FF40
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF40)
+      )
+   )
+(CHARACTER H FF41
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF41)
+      )
+   )
+(CHARACTER H FF42
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF42)
+      )
+   )
+(CHARACTER H FF43
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF43)
+      )
+   )
+(CHARACTER H FF44
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF44)
+      )
+   )
+(CHARACTER H FF45
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF45)
+      )
+   )
+(CHARACTER H FF46
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF46)
+      )
+   )
+(CHARACTER H FF47
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF47)
+      )
+   )
+(CHARACTER H FF48
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF48)
+      )
+   )
+(CHARACTER H FF49
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF49)
+      )
+   )
+(CHARACTER H FF4A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4A)
+      )
+   )
+(CHARACTER H FF4B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4B)
+      )
+   )
+(CHARACTER H FF4C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4C)
+      )
+   )
+(CHARACTER H FF4D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4D)
+      )
+   )
+(CHARACTER H FF4E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4E)
+      )
+   )
+(CHARACTER H FF4F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4F)
+      )
+   )
+(CHARACTER H FF50
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF50)
+      )
+   )
+(CHARACTER H FF51
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF51)
+      )
+   )
+(CHARACTER H FF52
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF52)
+      )
+   )
+(CHARACTER H FF53
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF53)
+      )
+   )
+(CHARACTER H FF54
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF54)
+      )
+   )
+(CHARACTER H FF55
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF55)
+      )
+   )
+(CHARACTER H FF56
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF56)
+      )
+   )
+(CHARACTER H FF57
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF57)
+      )
+   )
+(CHARACTER H FF58
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF58)
+      )
+   )
+(CHARACTER H FF59
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF59)
+      )
+   )
+(CHARACTER H FF5A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5A)
+      )
+   )
+(CHARACTER H FF5B
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF5B)
+      )
+   )
+(CHARACTER H FF5C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5C)
+      )
+   )
+(CHARACTER H FF5D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5D)
+      )
+   )
+(CHARACTER H FF5E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5E)
+      )
+   )
+(CHARACTER H FF5F
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF5F)
+      )
+   )
+(CHARACTER H FF60
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF60)
+      )
+   )
+(CHARACTER H FF61
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF61)
+      )
+   )
+(CHARACTER H FF62
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF62)
+      )
+   )
+(CHARACTER H FF63
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF63)
+      )
+   )
+(CHARACTER H FF64
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF64)
+      )
+   )
+(CHARACTER H FF65
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF65)
+      )
+   )
+(CHARACTER H FF66
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF66)
+      )
+   )
+(CHARACTER H FF67
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF67)
+      )
+   )
+(CHARACTER H FF68
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF68)
+      )
+   )
+(CHARACTER H FF69
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF69)
+      )
+   )
+(CHARACTER H FF6A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6A)
+      )
+   )
+(CHARACTER H FF6B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6B)
+      )
+   )
+(CHARACTER H FF6C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6C)
+      )
+   )
+(CHARACTER H FF6D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6D)
+      )
+   )
+(CHARACTER H FF6E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6E)
+      )
+   )
+(CHARACTER H FF6F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6F)
+      )
+   )
+(CHARACTER H FF70
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF70)
+      )
+   )
+(CHARACTER H FF71
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF71)
+      )
+   )
+(CHARACTER H FF72
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF72)
+      )
+   )
+(CHARACTER H FF73
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF73)
+      )
+   )
+(CHARACTER H FF74
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF74)
+      )
+   )
+(CHARACTER H FF75
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF75)
+      )
+   )
+(CHARACTER H FF76
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF76)
+      )
+   )
+(CHARACTER H FF77
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF77)
+      )
+   )
+(CHARACTER H FF78
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF78)
+      )
+   )
+(CHARACTER H FF79
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF79)
+      )
+   )
+(CHARACTER H FF7A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7A)
+      )
+   )
+(CHARACTER H FF7B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7B)
+      )
+   )
+(CHARACTER H FF7C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7C)
+      )
+   )
+(CHARACTER H FF7D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7D)
+      )
+   )
+(CHARACTER H FF7E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7E)
+      )
+   )
+(CHARACTER H FF7F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7F)
+      )
+   )
+(CHARACTER H FF80
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF80)
+      )
+   )
+(CHARACTER H FF81
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF81)
+      )
+   )
+(CHARACTER H FF82
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF82)
+      )
+   )
+(CHARACTER H FF83
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF83)
+      )
+   )
+(CHARACTER H FF84
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF84)
+      )
+   )
+(CHARACTER H FF85
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF85)
+      )
+   )
+(CHARACTER H FF86
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF86)
+      )
+   )
+(CHARACTER H FF87
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF87)
+      )
+   )
+(CHARACTER H FF88
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF88)
+      )
+   )
+(CHARACTER H FF89
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF89)
+      )
+   )
+(CHARACTER H FF8A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8A)
+      )
+   )
+(CHARACTER H FF8B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8B)
+      )
+   )
+(CHARACTER H FF8C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8C)
+      )
+   )
+(CHARACTER H FF8D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8D)
+      )
+   )
+(CHARACTER H FF8E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8E)
+      )
+   )
+(CHARACTER H FF8F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8F)
+      )
+   )
+(CHARACTER H FF90
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF90)
+      )
+   )
+(CHARACTER H FF91
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF91)
+      )
+   )
+(CHARACTER H FF92
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF92)
+      )
+   )
+(CHARACTER H FF93
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF93)
+      )
+   )
+(CHARACTER H FF94
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF94)
+      )
+   )
+(CHARACTER H FF95
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF95)
+      )
+   )
+(CHARACTER H FF96
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF96)
+      )
+   )
+(CHARACTER H FF97
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF97)
+      )
+   )
+(CHARACTER H FF98
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF98)
+      )
+   )
+(CHARACTER H FF99
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF99)
+      )
+   )
+(CHARACTER H FF9A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9A)
+      )
+   )
+(CHARACTER H FF9B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9B)
+      )
+   )
+(CHARACTER H FF9C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9C)
+      )
+   )
+(CHARACTER H FF9D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9D)
+      )
+   )
+(CHARACTER H FF9E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9E)
+      )
+   )
+(CHARACTER H FF9F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9F)
+      )
+   )
+(CHARACTER H FFA0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA0)
+      )
+   )
+(CHARACTER H FFA1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA1)
+      )
+   )
+(CHARACTER H FFA2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA2)
+      )
+   )
+(CHARACTER H FFA3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA3)
+      )
+   )
+(CHARACTER H FFA4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA4)
+      )
+   )
+(CHARACTER H FFA5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA5)
+      )
+   )
+(CHARACTER H FFA6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA6)
+      )
+   )
+(CHARACTER H FFA7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA7)
+      )
+   )
+(CHARACTER H FFA8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA8)
+      )
+   )
+(CHARACTER H FFA9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA9)
+      )
+   )
+(CHARACTER H FFAA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAA)
+      )
+   )
+(CHARACTER H FFAB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAB)
+      )
+   )
+(CHARACTER H FFAC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAC)
+      )
+   )
+(CHARACTER H FFAD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAD)
+      )
+   )
+(CHARACTER H FFAE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAE)
+      )
+   )
+(CHARACTER H FFAF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAF)
+      )
+   )
+(CHARACTER H FFB0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB0)
+      )
+   )
+(CHARACTER H FFB1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB1)
+      )
+   )
+(CHARACTER H FFB2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB2)
+      )
+   )
+(CHARACTER H FFB3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB3)
+      )
+   )
+(CHARACTER H FFB4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB4)
+      )
+   )
+(CHARACTER H FFB5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB5)
+      )
+   )
+(CHARACTER H FFB6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB6)
+      )
+   )
+(CHARACTER H FFB7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB7)
+      )
+   )
+(CHARACTER H FFB8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB8)
+      )
+   )
+(CHARACTER H FFB9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB9)
+      )
+   )
+(CHARACTER H FFBA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBA)
+      )
+   )
+(CHARACTER H FFBB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBB)
+      )
+   )
+(CHARACTER H FFBC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBC)
+      )
+   )
+(CHARACTER H FFBD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBD)
+      )
+   )
+(CHARACTER H FFBE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBE)
+      )
+   )
+(CHARACTER H FFBF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBF)
+      )
+   )
+(CHARACTER H FFC0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC0)
+      )
+   )
+(CHARACTER H FFC1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC1)
+      )
+   )
+(CHARACTER H FFC2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC2)
+      )
+   )
+(CHARACTER H FFC3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC3)
+      )
+   )
+(CHARACTER H FFC4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC4)
+      )
+   )
+(CHARACTER H FFC5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC5)
+      )
+   )
+(CHARACTER H FFC6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC6)
+      )
+   )
+(CHARACTER H FFC7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC7)
+      )
+   )
+(CHARACTER H FFC8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC8)
+      )
+   )
+(CHARACTER H FFC9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC9)
+      )
+   )
+(CHARACTER H FFCA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCA)
+      )
+   )
+(CHARACTER H FFCB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCB)
+      )
+   )
+(CHARACTER H FFCC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCC)
+      )
+   )
+(CHARACTER H FFCD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCD)
+      )
+   )
+(CHARACTER H FFCE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCE)
+      )
+   )
+(CHARACTER H FFCF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCF)
+      )
+   )
+(CHARACTER H FFD0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD0)
+      )
+   )
+(CHARACTER H FFD1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD1)
+      )
+   )
+(CHARACTER H FFD2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD2)
+      )
+   )
+(CHARACTER H FFD3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD3)
+      )
+   )
+(CHARACTER H FFD4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD4)
+      )
+   )
+(CHARACTER H FFD5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD5)
+      )
+   )
+(CHARACTER H FFD6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD6)
+      )
+   )
+(CHARACTER H FFD7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD7)
+      )
+   )
+(CHARACTER H FFD8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD8)
+      )
+   )
+(CHARACTER H FFD9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD9)
+      )
+   )
+(CHARACTER H FFDA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDA)
+      )
+   )
+(CHARACTER H FFDB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDB)
+      )
+   )
+(CHARACTER H FFDC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDC)
+      )
+   )
+(CHARACTER H FFDD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDD)
+      )
+   )
+(CHARACTER H FFDE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDE)
+      )
+   )
+(CHARACTER H FFDF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDF)
+      )
+   )
+(CHARACTER H FFE0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE0)
+      )
+   )
+(CHARACTER H FFE1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE1)
+      )
+   )
+(CHARACTER H FFE2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE2)
+      )
+   )
+(CHARACTER H FFE3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE3)
+      )
+   )
+(CHARACTER H FFE4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE4)
+      )
+   )
+(CHARACTER H FFE5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE5)
+      )
+   )
+(CHARACTER H FFE6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE6)
+      )
+   )
+(CHARACTER H FFE7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE7)
+      )
+   )
+(CHARACTER H FFE8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE8)
+      )
+   )
+(CHARACTER H FFE9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE9)
+      )
+   )
+(CHARACTER H FFEA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEA)
+      )
+   )
+(CHARACTER H FFEB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEB)
+      )
+   )
+(CHARACTER H FFEC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEC)
+      )
+   )
+(CHARACTER H FFED
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFED)
+      )
+   )
+(CHARACTER H FFEE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEE)
+      )
+   )
+(CHARACTER H FFEF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEF)
+      )
+   )
+(CHARACTER H 1B05B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 3)
+      (SETCHAR H 1B05B)
+      )
+   )
+(CHARACTER H 1B081
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 3)
+      (SETCHAR H 1B081)
+      )
+   )
+(CHARACTER H 1B0A6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 3)
+      (SETCHAR H 1B0A6)
+      )
+   )
+(CHARACTER H 20B9F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 20B9F)
+      )
+   )
+(CHARACTER H 2F833
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 2F833)
+      )
+   )
+(CHARACTER H 23B0A6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 4)
+      (SETCHAR H EF6F)
+      )
+   )
+(CHARACTER H 24304B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 3F51)
+      )
+   )
+(CHARACTER H 2431F7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 3F76)
+      )
+   )
+(CHARACTER H 25B0A6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 4)
+      (SETCHAR H EF93)
+      )
+   )
+(CHARACTER H 48537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 2F833)
+      )
+   )
+(CHARACTER H 80537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 3597)
+      )
+   )
+(CHARACTER H 84537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 6A2)
+      )
+   )
+(CHARACTER H 88537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 1DED)
+      )
+   )
diff --git a/source/texk/dvipdfm-x/tests/upjv4_full.vf b/source/texk/dvipdfm-x/tests/upjv4_full.vf
new file mode 100644
index 000000000..bf1d13314
Binary files /dev/null and b/source/texk/dvipdfm-x/tests/upjv4_full.vf differ
diff --git a/source/texk/dvipdfm-x/tests/upjv4_full.zvp0 b/source/texk/dvipdfm-x/tests/upjv4_full.zvp0
new file mode 100644
index 000000000..86c44d974
--- /dev/null
+++ b/source/texk/dvipdfm-x/tests/upjv4_full.zvp0
@@ -0,0 +1,2989 @@
+(VTITLE )
+(DESIGNSIZE R 10.0)
+(CHECKSUM O 0)
+(MAPFONT D 0
+   (FONTNAME upjv-r)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 1
+   (FONTNAME upjv-g)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 2
+   (FONTNAME upjv-c)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 3
+   (FONTNAME upjv-hu)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 4
+   (FONTNAME upjv-hi)
+   (FONTCHECKSUM O 0)
+   (FONTAT R 1.0)
+   (FONTDSIZE R 10.0)
+   )
+(CHARACTER H 2600
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 2600)
+      )
+   )
+(CHARACTER H 2603
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 2603)
+      )
+   )
+(CHARACTER H 3000
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3000)
+      )
+   )
+(CHARACTER H 3001
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3001)
+      )
+   )
+(CHARACTER H 3002
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3002)
+      )
+   )
+(CHARACTER H 3003
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3003)
+      )
+   )
+(CHARACTER H 3004
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3004)
+      )
+   )
+(CHARACTER H 3005
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3005)
+      )
+   )
+(CHARACTER H 3006
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3006)
+      )
+   )
+(CHARACTER H 3007
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3007)
+      )
+   )
+(CHARACTER H 3008
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3008)
+      )
+   )
+(CHARACTER H 3009
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3009)
+      )
+   )
+(CHARACTER H 300A
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 300A)
+      )
+   )
+(CHARACTER H 300B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 300B)
+      )
+   )
+(CHARACTER H 300C
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 300C)
+      )
+   )
+(CHARACTER H 300D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 300D)
+      )
+   )
+(CHARACTER H 300E
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 300E)
+      )
+   )
+(CHARACTER H 300F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 300F)
+      )
+   )
+(CHARACTER H 3010
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3010)
+      )
+   )
+(CHARACTER H 3011
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3011)
+      )
+   )
+(CHARACTER H 3012
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3012)
+      )
+   )
+(CHARACTER H 3013
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3013)
+      )
+   )
+(CHARACTER H 3014
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3014)
+      )
+   )
+(CHARACTER H 3015
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3015)
+      )
+   )
+(CHARACTER H 3016
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3016)
+      )
+   )
+(CHARACTER H 3017
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3017)
+      )
+   )
+(CHARACTER H 3018
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 3018)
+      )
+   )
+(CHARACTER H 3019
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3019)
+      )
+   )
+(CHARACTER H 301A
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 301A)
+      )
+   )
+(CHARACTER H 301B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301B)
+      )
+   )
+(CHARACTER H 301C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301C)
+      )
+   )
+(CHARACTER H 301D
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H 301D)
+      )
+   )
+(CHARACTER H 301E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301E)
+      )
+   )
+(CHARACTER H 301F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 301F)
+      )
+   )
+(CHARACTER H 3020
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3020)
+      )
+   )
+(CHARACTER H 3021
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3021)
+      )
+   )
+(CHARACTER H 3022
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3022)
+      )
+   )
+(CHARACTER H 3023
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3023)
+      )
+   )
+(CHARACTER H 3024
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3024)
+      )
+   )
+(CHARACTER H 3025
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3025)
+      )
+   )
+(CHARACTER H 3026
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3026)
+      )
+   )
+(CHARACTER H 3027
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3027)
+      )
+   )
+(CHARACTER H 3028
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3028)
+      )
+   )
+(CHARACTER H 3029
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3029)
+      )
+   )
+(CHARACTER H 302A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302A)
+      )
+   )
+(CHARACTER H 302B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302B)
+      )
+   )
+(CHARACTER H 302C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302C)
+      )
+   )
+(CHARACTER H 302D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302D)
+      )
+   )
+(CHARACTER H 302E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302E)
+      )
+   )
+(CHARACTER H 302F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 302F)
+      )
+   )
+(CHARACTER H 3030
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3030)
+      )
+   )
+(CHARACTER H 3031
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3031)
+      )
+   )
+(CHARACTER H 3032
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3032)
+      )
+   )
+(CHARACTER H 3033
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3033)
+      )
+   )
+(CHARACTER H 3034
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3034)
+      )
+   )
+(CHARACTER H 3035
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3035)
+      )
+   )
+(CHARACTER H 3036
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3036)
+      )
+   )
+(CHARACTER H 3037
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3037)
+      )
+   )
+(CHARACTER H 3038
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3038)
+      )
+   )
+(CHARACTER H 3039
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3039)
+      )
+   )
+(CHARACTER H 303A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303A)
+      )
+   )
+(CHARACTER H 303B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303B)
+      )
+   )
+(CHARACTER H 303C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303C)
+      )
+   )
+(CHARACTER H 303D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303D)
+      )
+   )
+(CHARACTER H 303E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303E)
+      )
+   )
+(CHARACTER H 303F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 303F)
+      )
+   )
+(CHARACTER H 3040
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3040)
+      )
+   )
+(CHARACTER H 3041
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3041)
+      )
+   )
+(CHARACTER H 3042
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3042)
+      )
+   )
+(CHARACTER H 3043
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3043)
+      )
+   )
+(CHARACTER H 3044
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3044)
+      )
+   )
+(CHARACTER H 3045
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3045)
+      )
+   )
+(CHARACTER H 3046
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 3046)
+      )
+   )
+(CHARACTER H 3047
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3047)
+      )
+   )
+(CHARACTER H 3048
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3048)
+      )
+   )
+(CHARACTER H 3049
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3049)
+      )
+   )
+(CHARACTER H 304A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304A)
+      )
+   )
+(CHARACTER H 304B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304B)
+      )
+   )
+(CHARACTER H 304C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304C)
+      )
+   )
+(CHARACTER H 304D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304D)
+      )
+   )
+(CHARACTER H 304E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 304E)
+      )
+   )
+(CHARACTER H 304F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 304F)
+      )
+   )
+(CHARACTER H 3050
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3050)
+      )
+   )
+(CHARACTER H 3051
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3051)
+      )
+   )
+(CHARACTER H 3052
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3052)
+      )
+   )
+(CHARACTER H 3053
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3053)
+      )
+   )
+(CHARACTER H 3054
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3054)
+      )
+   )
+(CHARACTER H 3055
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3055)
+      )
+   )
+(CHARACTER H 3056
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3056)
+      )
+   )
+(CHARACTER H 3057
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3057)
+      )
+   )
+(CHARACTER H 3058
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3058)
+      )
+   )
+(CHARACTER H 3059
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3059)
+      )
+   )
+(CHARACTER H 305A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305A)
+      )
+   )
+(CHARACTER H 305B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305B)
+      )
+   )
+(CHARACTER H 305C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305C)
+      )
+   )
+(CHARACTER H 305D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305D)
+      )
+   )
+(CHARACTER H 305E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305E)
+      )
+   )
+(CHARACTER H 305F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 305F)
+      )
+   )
+(CHARACTER H 3060
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3060)
+      )
+   )
+(CHARACTER H 3061
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3061)
+      )
+   )
+(CHARACTER H 3062
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3062)
+      )
+   )
+(CHARACTER H 3063
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3063)
+      )
+   )
+(CHARACTER H 3064
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3064)
+      )
+   )
+(CHARACTER H 3065
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3065)
+      )
+   )
+(CHARACTER H 3066
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3066)
+      )
+   )
+(CHARACTER H 3067
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3067)
+      )
+   )
+(CHARACTER H 3068
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3068)
+      )
+   )
+(CHARACTER H 3069
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3069)
+      )
+   )
+(CHARACTER H 306A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306A)
+      )
+   )
+(CHARACTER H 306B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306B)
+      )
+   )
+(CHARACTER H 306C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306C)
+      )
+   )
+(CHARACTER H 306D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306D)
+      )
+   )
+(CHARACTER H 306E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306E)
+      )
+   )
+(CHARACTER H 306F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 306F)
+      )
+   )
+(CHARACTER H 3070
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3070)
+      )
+   )
+(CHARACTER H 3071
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3071)
+      )
+   )
+(CHARACTER H 3072
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3072)
+      )
+   )
+(CHARACTER H 3073
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3073)
+      )
+   )
+(CHARACTER H 3074
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3074)
+      )
+   )
+(CHARACTER H 3075
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3075)
+      )
+   )
+(CHARACTER H 3076
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3076)
+      )
+   )
+(CHARACTER H 3077
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3077)
+      )
+   )
+(CHARACTER H 3078
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3078)
+      )
+   )
+(CHARACTER H 3079
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3079)
+      )
+   )
+(CHARACTER H 307A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307A)
+      )
+   )
+(CHARACTER H 307B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307B)
+      )
+   )
+(CHARACTER H 307C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307C)
+      )
+   )
+(CHARACTER H 307D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307D)
+      )
+   )
+(CHARACTER H 307E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307E)
+      )
+   )
+(CHARACTER H 307F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 307F)
+      )
+   )
+(CHARACTER H 3080
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3080)
+      )
+   )
+(CHARACTER H 3081
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3081)
+      )
+   )
+(CHARACTER H 3082
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3082)
+      )
+   )
+(CHARACTER H 3083
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3083)
+      )
+   )
+(CHARACTER H 3084
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3084)
+      )
+   )
+(CHARACTER H 3085
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3085)
+      )
+   )
+(CHARACTER H 3086
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3086)
+      )
+   )
+(CHARACTER H 3087
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3087)
+      )
+   )
+(CHARACTER H 3088
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3088)
+      )
+   )
+(CHARACTER H 3089
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3089)
+      )
+   )
+(CHARACTER H 308A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308A)
+      )
+   )
+(CHARACTER H 308B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308B)
+      )
+   )
+(CHARACTER H 308C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308C)
+      )
+   )
+(CHARACTER H 308D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308D)
+      )
+   )
+(CHARACTER H 308E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308E)
+      )
+   )
+(CHARACTER H 308F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 308F)
+      )
+   )
+(CHARACTER H 3090
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3090)
+      )
+   )
+(CHARACTER H 3091
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3091)
+      )
+   )
+(CHARACTER H 3092
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3092)
+      )
+   )
+(CHARACTER H 3093
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3093)
+      )
+   )
+(CHARACTER H 3094
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3094)
+      )
+   )
+(CHARACTER H 3095
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3095)
+      )
+   )
+(CHARACTER H 3096
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3096)
+      )
+   )
+(CHARACTER H 3097
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3097)
+      )
+   )
+(CHARACTER H 3098
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3098)
+      )
+   )
+(CHARACTER H 3099
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 3099)
+      )
+   )
+(CHARACTER H 309A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309A)
+      )
+   )
+(CHARACTER H 309B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309B)
+      )
+   )
+(CHARACTER H 309C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309C)
+      )
+   )
+(CHARACTER H 309D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309D)
+      )
+   )
+(CHARACTER H 309E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309E)
+      )
+   )
+(CHARACTER H 309F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H 309F)
+      )
+   )
+(CHARACTER H 30FB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 30FB)
+      )
+   )
+(CHARACTER H 537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 537F)
+      )
+   )
+(CHARACTER H 6674
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 6674)
+      )
+   )
+(CHARACTER H 751F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 751F)
+      )
+   )
+(CHARACTER H 96EA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 96EA)
+      )
+   )
+(CHARACTER H FF00
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF00)
+      )
+   )
+(CHARACTER H FF01
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF01)
+      )
+   )
+(CHARACTER H FF02
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF02)
+      )
+   )
+(CHARACTER H FF03
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF03)
+      )
+   )
+(CHARACTER H FF04
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF04)
+      )
+   )
+(CHARACTER H FF05
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF05)
+      )
+   )
+(CHARACTER H FF06
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF06)
+      )
+   )
+(CHARACTER H FF07
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF07)
+      )
+   )
+(CHARACTER H FF08
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF08)
+      )
+   )
+(CHARACTER H FF09
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF09)
+      )
+   )
+(CHARACTER H FF0A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0A)
+      )
+   )
+(CHARACTER H FF0B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0B)
+      )
+   )
+(CHARACTER H FF0C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0C)
+      )
+   )
+(CHARACTER H FF0D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0D)
+      )
+   )
+(CHARACTER H FF0E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0E)
+      )
+   )
+(CHARACTER H FF0F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF0F)
+      )
+   )
+(CHARACTER H FF10
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF10)
+      )
+   )
+(CHARACTER H FF11
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF11)
+      )
+   )
+(CHARACTER H FF12
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF12)
+      )
+   )
+(CHARACTER H FF13
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF13)
+      )
+   )
+(CHARACTER H FF14
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF14)
+      )
+   )
+(CHARACTER H FF15
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF15)
+      )
+   )
+(CHARACTER H FF16
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF16)
+      )
+   )
+(CHARACTER H FF17
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF17)
+      )
+   )
+(CHARACTER H FF18
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF18)
+      )
+   )
+(CHARACTER H FF19
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF19)
+      )
+   )
+(CHARACTER H FF1A
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.25)
+      (SELECTFONT D 1)
+      (SETCHAR H FF1A)
+      )
+   )
+(CHARACTER H FF1B
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.25)
+      (SELECTFONT D 1)
+      (SETCHAR H FF1B)
+      )
+   )
+(CHARACTER H FF1C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1C)
+      )
+   )
+(CHARACTER H FF1D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1D)
+      )
+   )
+(CHARACTER H FF1E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1E)
+      )
+   )
+(CHARACTER H FF1F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF1F)
+      )
+   )
+(CHARACTER H FF20
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF20)
+      )
+   )
+(CHARACTER H FF21
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF21)
+      )
+   )
+(CHARACTER H FF22
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF22)
+      )
+   )
+(CHARACTER H FF23
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF23)
+      )
+   )
+(CHARACTER H FF24
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF24)
+      )
+   )
+(CHARACTER H FF25
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF25)
+      )
+   )
+(CHARACTER H FF26
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF26)
+      )
+   )
+(CHARACTER H FF27
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF27)
+      )
+   )
+(CHARACTER H FF28
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF28)
+      )
+   )
+(CHARACTER H FF29
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF29)
+      )
+   )
+(CHARACTER H FF2A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2A)
+      )
+   )
+(CHARACTER H FF2B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2B)
+      )
+   )
+(CHARACTER H FF2C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2C)
+      )
+   )
+(CHARACTER H FF2D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2D)
+      )
+   )
+(CHARACTER H FF2E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2E)
+      )
+   )
+(CHARACTER H FF2F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF2F)
+      )
+   )
+(CHARACTER H FF30
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF30)
+      )
+   )
+(CHARACTER H FF31
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF31)
+      )
+   )
+(CHARACTER H FF32
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF32)
+      )
+   )
+(CHARACTER H FF33
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF33)
+      )
+   )
+(CHARACTER H FF34
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF34)
+      )
+   )
+(CHARACTER H FF35
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF35)
+      )
+   )
+(CHARACTER H FF36
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF36)
+      )
+   )
+(CHARACTER H FF37
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF37)
+      )
+   )
+(CHARACTER H FF38
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF38)
+      )
+   )
+(CHARACTER H FF39
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF39)
+      )
+   )
+(CHARACTER H FF3A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3A)
+      )
+   )
+(CHARACTER H FF3B
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF3B)
+      )
+   )
+(CHARACTER H FF3C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3C)
+      )
+   )
+(CHARACTER H FF3D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3D)
+      )
+   )
+(CHARACTER H FF3E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3E)
+      )
+   )
+(CHARACTER H FF3F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF3F)
+      )
+   )
+(CHARACTER H FF40
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF40)
+      )
+   )
+(CHARACTER H FF41
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF41)
+      )
+   )
+(CHARACTER H FF42
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF42)
+      )
+   )
+(CHARACTER H FF43
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF43)
+      )
+   )
+(CHARACTER H FF44
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF44)
+      )
+   )
+(CHARACTER H FF45
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF45)
+      )
+   )
+(CHARACTER H FF46
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF46)
+      )
+   )
+(CHARACTER H FF47
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF47)
+      )
+   )
+(CHARACTER H FF48
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF48)
+      )
+   )
+(CHARACTER H FF49
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF49)
+      )
+   )
+(CHARACTER H FF4A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4A)
+      )
+   )
+(CHARACTER H FF4B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4B)
+      )
+   )
+(CHARACTER H FF4C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4C)
+      )
+   )
+(CHARACTER H FF4D
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4D)
+      )
+   )
+(CHARACTER H FF4E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4E)
+      )
+   )
+(CHARACTER H FF4F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF4F)
+      )
+   )
+(CHARACTER H FF50
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF50)
+      )
+   )
+(CHARACTER H FF51
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF51)
+      )
+   )
+(CHARACTER H FF52
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF52)
+      )
+   )
+(CHARACTER H FF53
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF53)
+      )
+   )
+(CHARACTER H FF54
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF54)
+      )
+   )
+(CHARACTER H FF55
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF55)
+      )
+   )
+(CHARACTER H FF56
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF56)
+      )
+   )
+(CHARACTER H FF57
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF57)
+      )
+   )
+(CHARACTER H FF58
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF58)
+      )
+   )
+(CHARACTER H FF59
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF59)
+      )
+   )
+(CHARACTER H FF5A
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5A)
+      )
+   )
+(CHARACTER H FF5B
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF5B)
+      )
+   )
+(CHARACTER H FF5C
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5C)
+      )
+   )
+(CHARACTER H FF5D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5D)
+      )
+   )
+(CHARACTER H FF5E
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF5E)
+      )
+   )
+(CHARACTER H FF5F
+   (CHARWD R 0.5)
+   (MAP
+      (MOVERIGHT R -0.5)
+      (SELECTFONT D 1)
+      (SETCHAR H FF5F)
+      )
+   )
+(CHARACTER H FF60
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF60)
+      )
+   )
+(CHARACTER H FF61
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF61)
+      )
+   )
+(CHARACTER H FF62
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF62)
+      )
+   )
+(CHARACTER H FF63
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF63)
+      )
+   )
+(CHARACTER H FF64
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF64)
+      )
+   )
+(CHARACTER H FF65
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF65)
+      )
+   )
+(CHARACTER H FF66
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF66)
+      )
+   )
+(CHARACTER H FF67
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF67)
+      )
+   )
+(CHARACTER H FF68
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF68)
+      )
+   )
+(CHARACTER H FF69
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF69)
+      )
+   )
+(CHARACTER H FF6A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6A)
+      )
+   )
+(CHARACTER H FF6B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6B)
+      )
+   )
+(CHARACTER H FF6C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6C)
+      )
+   )
+(CHARACTER H FF6D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6D)
+      )
+   )
+(CHARACTER H FF6E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6E)
+      )
+   )
+(CHARACTER H FF6F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF6F)
+      )
+   )
+(CHARACTER H FF70
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF70)
+      )
+   )
+(CHARACTER H FF71
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF71)
+      )
+   )
+(CHARACTER H FF72
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF72)
+      )
+   )
+(CHARACTER H FF73
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF73)
+      )
+   )
+(CHARACTER H FF74
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF74)
+      )
+   )
+(CHARACTER H FF75
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF75)
+      )
+   )
+(CHARACTER H FF76
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF76)
+      )
+   )
+(CHARACTER H FF77
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF77)
+      )
+   )
+(CHARACTER H FF78
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF78)
+      )
+   )
+(CHARACTER H FF79
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF79)
+      )
+   )
+(CHARACTER H FF7A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7A)
+      )
+   )
+(CHARACTER H FF7B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7B)
+      )
+   )
+(CHARACTER H FF7C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7C)
+      )
+   )
+(CHARACTER H FF7D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7D)
+      )
+   )
+(CHARACTER H FF7E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7E)
+      )
+   )
+(CHARACTER H FF7F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF7F)
+      )
+   )
+(CHARACTER H FF80
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF80)
+      )
+   )
+(CHARACTER H FF81
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF81)
+      )
+   )
+(CHARACTER H FF82
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF82)
+      )
+   )
+(CHARACTER H FF83
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF83)
+      )
+   )
+(CHARACTER H FF84
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF84)
+      )
+   )
+(CHARACTER H FF85
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF85)
+      )
+   )
+(CHARACTER H FF86
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF86)
+      )
+   )
+(CHARACTER H FF87
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF87)
+      )
+   )
+(CHARACTER H FF88
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF88)
+      )
+   )
+(CHARACTER H FF89
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF89)
+      )
+   )
+(CHARACTER H FF8A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8A)
+      )
+   )
+(CHARACTER H FF8B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8B)
+      )
+   )
+(CHARACTER H FF8C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8C)
+      )
+   )
+(CHARACTER H FF8D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8D)
+      )
+   )
+(CHARACTER H FF8E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8E)
+      )
+   )
+(CHARACTER H FF8F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF8F)
+      )
+   )
+(CHARACTER H FF90
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF90)
+      )
+   )
+(CHARACTER H FF91
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF91)
+      )
+   )
+(CHARACTER H FF92
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF92)
+      )
+   )
+(CHARACTER H FF93
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF93)
+      )
+   )
+(CHARACTER H FF94
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF94)
+      )
+   )
+(CHARACTER H FF95
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF95)
+      )
+   )
+(CHARACTER H FF96
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF96)
+      )
+   )
+(CHARACTER H FF97
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF97)
+      )
+   )
+(CHARACTER H FF98
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF98)
+      )
+   )
+(CHARACTER H FF99
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF99)
+      )
+   )
+(CHARACTER H FF9A
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9A)
+      )
+   )
+(CHARACTER H FF9B
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9B)
+      )
+   )
+(CHARACTER H FF9C
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9C)
+      )
+   )
+(CHARACTER H FF9D
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9D)
+      )
+   )
+(CHARACTER H FF9E
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9E)
+      )
+   )
+(CHARACTER H FF9F
+   (CHARWD R 0.5)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FF9F)
+      )
+   )
+(CHARACTER H FFA0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA0)
+      )
+   )
+(CHARACTER H FFA1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA1)
+      )
+   )
+(CHARACTER H FFA2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA2)
+      )
+   )
+(CHARACTER H FFA3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA3)
+      )
+   )
+(CHARACTER H FFA4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA4)
+      )
+   )
+(CHARACTER H FFA5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA5)
+      )
+   )
+(CHARACTER H FFA6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA6)
+      )
+   )
+(CHARACTER H FFA7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA7)
+      )
+   )
+(CHARACTER H FFA8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA8)
+      )
+   )
+(CHARACTER H FFA9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFA9)
+      )
+   )
+(CHARACTER H FFAA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAA)
+      )
+   )
+(CHARACTER H FFAB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAB)
+      )
+   )
+(CHARACTER H FFAC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAC)
+      )
+   )
+(CHARACTER H FFAD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAD)
+      )
+   )
+(CHARACTER H FFAE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAE)
+      )
+   )
+(CHARACTER H FFAF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFAF)
+      )
+   )
+(CHARACTER H FFB0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB0)
+      )
+   )
+(CHARACTER H FFB1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB1)
+      )
+   )
+(CHARACTER H FFB2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB2)
+      )
+   )
+(CHARACTER H FFB3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB3)
+      )
+   )
+(CHARACTER H FFB4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB4)
+      )
+   )
+(CHARACTER H FFB5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB5)
+      )
+   )
+(CHARACTER H FFB6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB6)
+      )
+   )
+(CHARACTER H FFB7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB7)
+      )
+   )
+(CHARACTER H FFB8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB8)
+      )
+   )
+(CHARACTER H FFB9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFB9)
+      )
+   )
+(CHARACTER H FFBA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBA)
+      )
+   )
+(CHARACTER H FFBB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBB)
+      )
+   )
+(CHARACTER H FFBC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBC)
+      )
+   )
+(CHARACTER H FFBD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBD)
+      )
+   )
+(CHARACTER H FFBE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBE)
+      )
+   )
+(CHARACTER H FFBF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFBF)
+      )
+   )
+(CHARACTER H FFC0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC0)
+      )
+   )
+(CHARACTER H FFC1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC1)
+      )
+   )
+(CHARACTER H FFC2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC2)
+      )
+   )
+(CHARACTER H FFC3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC3)
+      )
+   )
+(CHARACTER H FFC4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC4)
+      )
+   )
+(CHARACTER H FFC5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC5)
+      )
+   )
+(CHARACTER H FFC6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC6)
+      )
+   )
+(CHARACTER H FFC7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC7)
+      )
+   )
+(CHARACTER H FFC8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC8)
+      )
+   )
+(CHARACTER H FFC9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFC9)
+      )
+   )
+(CHARACTER H FFCA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCA)
+      )
+   )
+(CHARACTER H FFCB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCB)
+      )
+   )
+(CHARACTER H FFCC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCC)
+      )
+   )
+(CHARACTER H FFCD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCD)
+      )
+   )
+(CHARACTER H FFCE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCE)
+      )
+   )
+(CHARACTER H FFCF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFCF)
+      )
+   )
+(CHARACTER H FFD0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD0)
+      )
+   )
+(CHARACTER H FFD1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD1)
+      )
+   )
+(CHARACTER H FFD2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD2)
+      )
+   )
+(CHARACTER H FFD3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD3)
+      )
+   )
+(CHARACTER H FFD4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD4)
+      )
+   )
+(CHARACTER H FFD5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD5)
+      )
+   )
+(CHARACTER H FFD6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD6)
+      )
+   )
+(CHARACTER H FFD7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD7)
+      )
+   )
+(CHARACTER H FFD8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD8)
+      )
+   )
+(CHARACTER H FFD9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFD9)
+      )
+   )
+(CHARACTER H FFDA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDA)
+      )
+   )
+(CHARACTER H FFDB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDB)
+      )
+   )
+(CHARACTER H FFDC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDC)
+      )
+   )
+(CHARACTER H FFDD
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDD)
+      )
+   )
+(CHARACTER H FFDE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDE)
+      )
+   )
+(CHARACTER H FFDF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFDF)
+      )
+   )
+(CHARACTER H FFE0
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE0)
+      )
+   )
+(CHARACTER H FFE1
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE1)
+      )
+   )
+(CHARACTER H FFE2
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE2)
+      )
+   )
+(CHARACTER H FFE3
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE3)
+      )
+   )
+(CHARACTER H FFE4
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE4)
+      )
+   )
+(CHARACTER H FFE5
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE5)
+      )
+   )
+(CHARACTER H FFE6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE6)
+      )
+   )
+(CHARACTER H FFE7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE7)
+      )
+   )
+(CHARACTER H FFE8
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE8)
+      )
+   )
+(CHARACTER H FFE9
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFE9)
+      )
+   )
+(CHARACTER H FFEA
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEA)
+      )
+   )
+(CHARACTER H FFEB
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEB)
+      )
+   )
+(CHARACTER H FFEC
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEC)
+      )
+   )
+(CHARACTER H FFED
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFED)
+      )
+   )
+(CHARACTER H FFEE
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEE)
+      )
+   )
+(CHARACTER H FFEF
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 1)
+      (SETCHAR H FFEF)
+      )
+   )
+(CHARACTER H 1B05B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 3)
+      (SETCHAR H 1B05B)
+      )
+   )
+(CHARACTER H 1B081
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 3)
+      (SETCHAR H 1B081)
+      )
+   )
+(CHARACTER H 1B0A6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 3)
+      (SETCHAR H 1B0A6)
+      )
+   )
+(CHARACTER H 20B9F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 20B9F)
+      )
+   )
+(CHARACTER H 2F833
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 2F833)
+      )
+   )
+(CHARACTER H 23B0A6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 4)
+      (SETCHAR H EF6F)
+      )
+   )
+(CHARACTER H 24304B
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 3F51)
+      )
+   )
+(CHARACTER H 2431F7
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 3FD7)
+      )
+   )
+(CHARACTER H 25B0A6
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 4)
+      (SETCHAR H EF93)
+      )
+   )
+(CHARACTER H 48537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 0)
+      (SETCHAR H 2F833)
+      )
+   )
+(CHARACTER H 80537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 3597)
+      )
+   )
+(CHARACTER H 84537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 6A2)
+      )
+   )
+(CHARACTER H 88537F
+   (CHARWD R 1.0)
+   (MAP
+      (SELECTFONT D 2)
+      (SETCHAR H 1DED)
+      )
+   )
diff --git a/source/texk/web2c/Makefile.in b/source/texk/web2c/Makefile.in
index 98813e302..9f1c3cab3 100644
--- a/source/texk/web2c/Makefile.in
+++ b/source/texk/web2c/Makefile.in
@@ -3244,22 +3244,24 @@ EXTRA_DIST = PROJECTS cftests cpascal.h help.h w2c/config.h \
 	euptexdir/euptrip/euptrip.diffs euptexdir/euptrip/texmf.cnf \
 	euptexdir/pdfprimitive.test \
 	euptexdir/tests/pdfprimitive-test.tex \
-	euptexdir/tests/pdfprimitive-euptex.log hitexdir/ChangeLog \
-	$(hitex_web) $(hitex_tests) hitexdir/tests/hello.tex \
-	hitexdir/tests/rule.tex pdftexdir/regex/COPYING.LIB \
-	pdftexdir/regex/README $(pdftex_ch_srcs) \
-	pdftexdir/pdftex.defines pdftexdir/ChangeLog pdftexdir/NEWS \
-	pdftexdir/README pdftexdir/change-files.txt $(pdftex_tests) \
-	tests/wprob.tex pdftexdir/tests/pdfimage.tex tests/1-4.jpg \
-	tests/B.pdf tests/basic.tex tests/lily-ledger-broken.png \
-	tests/expanded.tex tests/expanded.txt tests/cnfline.tex \
-	tests/partoken-ok.tex tests/partoken-xfail.tex \
-	$(ttf2afm_tests) pdftexdir/tests/postV3.afm \
-	pdftexdir/tests/postV3.ttf pdftexdir/tests/postV7.afm \
-	pdftexdir/tests/postV7.ttf $(pdftosrc_tests) \
-	pdftexdir/tests/test-13.pdf pdftexdir/tests/test-13.xref \
-	pdftexdir/tests/test-15.pdf pdftexdir/tests/test-15.xref \
-	$(libluasocket_sources) luatexdir/luasocket/src/ftp_lua.c \
+	euptexdir/tests/pdfprimitive-euptex.log \
+	euptexdir/tests/ctrlsym.log euptexdir/tests/ctrlsym.tex \
+	hitexdir/ChangeLog $(hitex_web) $(hitex_tests) \
+	hitexdir/tests/hello.tex hitexdir/tests/rule.tex \
+	pdftexdir/regex/COPYING.LIB pdftexdir/regex/README \
+	$(pdftex_ch_srcs) pdftexdir/pdftex.defines pdftexdir/ChangeLog \
+	pdftexdir/NEWS pdftexdir/README pdftexdir/change-files.txt \
+	$(pdftex_tests) tests/wprob.tex pdftexdir/tests/pdfimage.tex \
+	tests/1-4.jpg tests/B.pdf tests/basic.tex \
+	tests/lily-ledger-broken.png tests/expanded.tex \
+	tests/expanded.txt tests/cnfline.tex tests/partoken-ok.tex \
+	tests/partoken-xfail.tex $(ttf2afm_tests) \
+	pdftexdir/tests/postV3.afm pdftexdir/tests/postV3.ttf \
+	pdftexdir/tests/postV7.afm pdftexdir/tests/postV7.ttf \
+	$(pdftosrc_tests) pdftexdir/tests/test-13.pdf \
+	pdftexdir/tests/test-13.xref pdftexdir/tests/test-15.pdf \
+	pdftexdir/tests/test-15.xref $(libluasocket_sources) \
+	luatexdir/luasocket/src/ftp_lua.c \
 	luatexdir/luasocket/src/headers_lua.c \
 	luatexdir/luasocket/src/http_lua.c \
 	luatexdir/luasocket/src/ltn12_lua.c \
@@ -3445,7 +3447,8 @@ EXTRA_DIST = PROJECTS cftests cpascal.h help.h w2c/config.h \
 	xetexdir/unicode-char-prep.pl xetexdir/xewebmac.tex \
 	$(xetex_tests) xetexdir/tests/bug73.log \
 	xetexdir/tests/bug73.tex xetexdir/tests/filedump.log \
-	xetexdir/tests/filedump.tex omegaware/README \
+	xetexdir/tests/filedump.tex xetexdir/tests/ctrlsym.log \
+	xetexdir/tests/ctrlsym.tex omegaware/README \
 	omegaware/ChangeLog $(odvicopy_sources) $(odvitype_sources) \
 	omegaware/ofm2opl.web omegaware/ofm2opl.up \
 	omegaware/ofm2opl.ch omegaware/opl2ofm.web \
@@ -3568,7 +3571,8 @@ DISTCLEANFILES = CXXLD.sh tangle.c tangle.h tangle.p tangle-web2c \
 	uptests/ygk256*.* uptests/xskipjfmp.* uptrip.diffs \
 	$(nodist_euptex_SOURCES) euptex.web euptex.ch euptex-web2c \
 	euptex.p euptex.pool euptex-tangle euptrip.diffs \
-	pdfprimitive-euptex.* $(nodist_hitex_SOURCES) \
+	pdfprimitive-euptex.* eup-ctrlsym.fmt eup-ctrlsym.log \
+	eup-ctrlsym.out eup-ctrlsym.tex $(nodist_hitex_SOURCES) \
 	$(nodist_hishrink_SOURCES) $(nodist_histretch_SOURCES) \
 	hiformat-tangle hitex-tangle hello.log rule.log \
 	$(nodist_pdftex_SOURCES) pdftex-final.ch pdftex-web2c pdftex.p \
@@ -3579,26 +3583,28 @@ DISTCLEANFILES = CXXLD.sh tangle.c tangle.h tangle.p tangle-web2c \
 	$(nodist_libluatex_sources) luaimage.* luajitimage.* \
 	$(nodist_xetex_SOURCES) xetex.web xetex-final.ch xetex-web2c \
 	xetex.p xetex.pool xetex-tangle bug73.fmt bug73.log bug73.out \
-	bug73.tex filedump.log filedump.out filedump.tex xetests/fn*.* \
-	$(omegaware_programs:=.c) $(omegaware_programs:=.h) \
-	$(omegaware_programs:=.p) $(omegaware_programs:=-web2c) \
-	ofm2opl.web opl2ofm.web ovf2ovp.web ovp2ovf.web \
-	omegaware/bad*.* omegaware/tests/charwdr.* \
-	omegaware/tests/charwdv.* omegaware/tests/xcheck* \
-	omegaware/tests/xlevel1.* omegaware/tests/xlig*.* ofont*vf \
-	omegaware/tests/xpagenum.* omegaware/tests/xofont* \
-	omegaware/tests/Cherokee.tfm omegaware/tests/OCherokee.ofm \
-	omegaware/tests/OCherokee.opl omegaware/tests/OCherokee.ovf \
-	omegaware/tests/xCherokee.* omegaware/tests/xOCherokee.* \
-	ocftest.* omegaware/tests/xinbmp* omegaware/tests/xoverbmp* \
-	omegaware/tests/xrealnum.* omegaware/tests/xrepeated.* \
-	omegaware/tests/sample*.ofm omegaware/tests/sample*.ovf \
-	omegaware/tests/sample1-h.opl omegaware/tests/xsample*.out \
-	omegaware/tests/shortend.* omegaware/tests/specialhex.ofm \
-	omegaware/tests/specialhex.opl omegaware/tests/specialhex.ovf \
-	omegaware/tests/xspecialhex.* omegaware/tests/yrepeat* \
-	omegaware/tests/*yarabic* $(nodist_aleph_SOURCES) aleph.web \
-	aleph.ch aleph-web2c aleph.p aleph.pool aleph-tangle
+	bug73.tex filedump.log filedump.out filedump.tex \
+	xe-ctrlsym.fmt xe-ctrlsym.log xe-ctrlsym.out xe-ctrlsym.tex \
+	xetests/fn*.* $(omegaware_programs:=.c) \
+	$(omegaware_programs:=.h) $(omegaware_programs:=.p) \
+	$(omegaware_programs:=-web2c) ofm2opl.web opl2ofm.web \
+	ovf2ovp.web ovp2ovf.web omegaware/bad*.* \
+	omegaware/tests/charwdr.* omegaware/tests/charwdv.* \
+	omegaware/tests/xcheck* omegaware/tests/xlevel1.* \
+	omegaware/tests/xlig*.* ofont*vf omegaware/tests/xpagenum.* \
+	omegaware/tests/xofont* omegaware/tests/Cherokee.tfm \
+	omegaware/tests/OCherokee.ofm omegaware/tests/OCherokee.opl \
+	omegaware/tests/OCherokee.ovf omegaware/tests/xCherokee.* \
+	omegaware/tests/xOCherokee.* ocftest.* omegaware/tests/xinbmp* \
+	omegaware/tests/xoverbmp* omegaware/tests/xrealnum.* \
+	omegaware/tests/xrepeated.* omegaware/tests/sample*.ofm \
+	omegaware/tests/sample*.ovf omegaware/tests/sample1-h.opl \
+	omegaware/tests/xsample*.out omegaware/tests/shortend.* \
+	omegaware/tests/specialhex.ofm omegaware/tests/specialhex.opl \
+	omegaware/tests/specialhex.ovf omegaware/tests/xspecialhex.* \
+	omegaware/tests/yrepeat* omegaware/tests/*yarabic* \
+	$(nodist_aleph_SOURCES) aleph.web aleph.ch aleph-web2c aleph.p \
+	aleph.pool aleph-tangle
 CLEANFILES = $(EXTRA_PROGRAMS) $(EXTRA_LIBRARIES) $(EXTRA_LTLIBRARIES)
 TRIPTRAP_CLEAN = $(am__append_8) $(am__append_18) $(am__append_27) \
 	$(am__append_36) $(am__append_44) $(am__append_60) \
@@ -4511,6 +4517,7 @@ euptex_ch_srcs = \
 euptex_tests = \
 	euptexdir/euptriptest.test euptexdir/eptriptest.test \
 	euptexdir/pdfprimitive.test \
+	euptexdir/euptex-ctrlsym.test \
 	euptexdir/eupver.test \
 	euptexdir/upkcat.test \
 	euptexdir/wcfname.test euptexdir/wcfname0.test
@@ -5370,6 +5377,7 @@ libxetex_prereq = xetexd.h $(xetex_dependencies)
 xetex_tests = \
 	xetexdir/xetex-filedump.test \
 	xetexdir/xetex-bug73.test \
+	xetexdir/xetex-ctrlsym.test \
 	xetexdir/xetex.test \
 	xetexdir/wcfname.test
 
@@ -21980,7 +21988,8 @@ euptex.ch: tie$(EXEEXT) euptex.web $(euptex_ch_srcs)
 euptexdir/euptriptest.log euptexdir/eptriptest.log: \
 	euptex$(EXEEXT) dvitype$(EXEEXT) pltotf$(EXEEXT) tftopl$(EXEEXT)
 euptexdir/pdfprimitive.log: euptex$(EXEEXT)
-euptexdir/eupver.log euptexdir/upkcat.log \
+euptexdir/euptex-ctrlsym.log \
+	euptexdir/eupver.log euptexdir/upkcat.log \
 	euptexdir/wcfname.log euptexdir/wcfname0.log: euptex$(EXEEXT)
 euptrip.diffs: euptex$(EXEEXT) dvitype$(EXEEXT) pltotf$(EXEEXT) tftopl$(EXEEXT)
 	$(triptrap_diffs) $@
@@ -22202,7 +22211,8 @@ $(srcdir)/xetexdir/xetex_version.h: @MAINTAINER_MODE_TRUE@ xetexdir/xetex.web
 xetex-final.ch: tie$(EXEEXT) $(xetex_ch_srcs)
 	$(tie_c) $(xetex_ch_srcs)
 $(libxetex_a_OBJECTS): $(libxetex_prereq)
-xetexdir/xetex-filedump.log xetexdir/xetex-bug73.log xetexdir/xetex.log \
+xetexdir/xetex-filedump.log xetexdir/xetex-bug73.log \
+  xetexdir/xetex-ctrlsym.log xetexdir/xetex.log \
   xetexdir/wcfname.log: xetex$(EXEEXT)
 
 # (end of xetex.am)
diff --git a/source/texk/web2c/euptexdir/ChangeLog b/source/texk/web2c/euptexdir/ChangeLog
index 5d39c9205..34397d189 100644
--- a/source/texk/web2c/euptexdir/ChangeLog
+++ b/source/texk/web2c/euptexdir/ChangeLog
@@ -1,3 +1,10 @@
+2024-05-18  TANAKA Takuji  <ttk@t-lab.opal.ne.jp>
+
+	* euptex-ctrlsym.test, tests/ctrlsym.{tex,log},
+	am/euptex.am: Add tests for getting character codes
+	from control symbols by using backquote "`".
+	https://github.com/texjporg/tex-jp-build/issues/167
+
 2024-05-01  TANAKA Takuji  <ttk@t-lab.opal.ne.jp>
 
 	* pdfutils.ch: Revert some patches.
diff --git a/source/texk/web2c/euptexdir/am/euptex.am b/source/texk/web2c/euptexdir/am/euptex.am
index 1103cc70d..f961b447f 100644
--- a/source/texk/web2c/euptexdir/am/euptex.am
+++ b/source/texk/web2c/euptexdir/am/euptex.am
@@ -98,13 +98,15 @@ EXTRA_DIST += \
 euptex_tests = \
 	euptexdir/euptriptest.test euptexdir/eptriptest.test \
 	euptexdir/pdfprimitive.test \
+	euptexdir/euptex-ctrlsym.test \
 	euptexdir/eupver.test \
 	euptexdir/upkcat.test \
 	euptexdir/wcfname.test euptexdir/wcfname0.test
 euptexdir/euptriptest.log euptexdir/eptriptest.log: \
 	euptex$(EXEEXT) dvitype$(EXEEXT) pltotf$(EXEEXT) tftopl$(EXEEXT)
 euptexdir/pdfprimitive.log: euptex$(EXEEXT)
-euptexdir/eupver.log euptexdir/upkcat.log \
+euptexdir/euptex-ctrlsym.log \
+	euptexdir/eupver.log euptexdir/upkcat.log \
 	euptexdir/wcfname.log euptexdir/wcfname0.log: euptex$(EXEEXT)
 
 EXTRA_DIST += $(euptex_tests)
@@ -136,4 +138,8 @@ EXTRA_DIST += \
 	euptexdir/tests/pdfprimitive-euptex.log
 DISTCLEANFILES += pdfprimitive-euptex.*
 
+## euptex-ctrlsym.test
+EXTRA_DIST += euptexdir/tests/ctrlsym.log euptexdir/tests/ctrlsym.tex
+DISTCLEANFILES += eup-ctrlsym.fmt eup-ctrlsym.log eup-ctrlsym.out eup-ctrlsym.tex
+
 # (end of euptex.am)
diff --git a/source/texk/web2c/euptexdir/euptex-ctrlsym.test b/source/texk/web2c/euptexdir/euptex-ctrlsym.test
new file mode 100755
index 000000000..294e0cf0b
--- /dev/null
+++ b/source/texk/web2c/euptexdir/euptex-ctrlsym.test
@@ -0,0 +1,28 @@
+#! /bin/sh -vx
+# Copyright 2024 Japanese TeX Development Community <issue@texjp.org>
+# You may freely use, modify and/or distribute this file.
+
+BinDir=${BinDir:-.}
+ExeExt=${ExeExt:-}
+_euptex=$BinDir/euptex$ExeExt
+
+LC_ALL=C; export LC_ALL;  LANGUAGE=C; export LANGUAGE
+
+TEXMFCNF=$srcdir/../kpathsea;export TEXMFCNF
+TEXINPUTS=".;$srcdir/tests"; export TEXINPUTS
+TEXFORMATS=.; export TEXFORMATS
+
+# get same filename in log
+rm -f eup-ctrlsym.tex
+$LN_S $srcdir/euptexdir/tests/ctrlsym.tex ./eup-ctrlsym.tex
+
+#exit 77
+
+$_euptex -ini -etex eup-ctrlsym || exit 1
+
+$_euptex -etex -fmt=eup-ctrlsym eup-ctrlsym || exit 2
+
+sed 1d eup-ctrlsym.log >eup-ctrlsym.out
+
+diff $srcdir/euptexdir/tests/ctrlsym.log eup-ctrlsym.out || exit 3
+
diff --git a/source/texk/web2c/euptexdir/tests/ctrlsym.log b/source/texk/web2c/euptexdir/tests/ctrlsym.log
new file mode 100644
index 000000000..1d0eae0c9
--- /dev/null
+++ b/source/texk/web2c/euptexdir/tests/ctrlsym.log
@@ -0,0 +1,20 @@
+entering extended mode
+ restricted \write18 enabled.
+ %&-line parsing enabled.
+**eup-ctrlsym
+(./eup-ctrlsym.tex 
+A: 38634
+
+\雪 ->snow
+B: 38634. 雪\雪snow
+macro:->snow.
+macro:->snow.
+
+C: 127820
+
+\🍌->banana
+D: 127820. 🍌\🍌 banana
+macro:->banana.
+macro:->banana.
+ )
+No pages of output.
diff --git a/source/texk/web2c/euptexdir/tests/ctrlsym.tex b/source/texk/web2c/euptexdir/tests/ctrlsym.tex
new file mode 100644
index 000000000..f007708a2
--- /dev/null
+++ b/source/texk/web2c/euptexdir/tests/ctrlsym.tex
@@ -0,0 +1,34 @@
+% Copyright 2024 Japanese TeX Development Community <issue@texjp.org>
+% You may freely use, modify and/or distribute this file.
+%
+\ifx\fmtname\undefined
+  \input basic
+  \def\fmtname{basic}
+  \expandafter\dump
+\fi
+%==================
+\begingroup % Just there to minimize tracing output
+  \tracingmacros=2
+  \tracingonline=1
+%--
+  \newlinechar=10
+  \count255=0
+  \count255=`雪 \relax
+  \message{^^JA: \the\count255^^J}
+  \def\雪{snow}
+  \count255=`\雪 \relax
+  \message{B: \the\count255. 雪\string\雪 \雪^^J}
+  \message{\expandafter\meaning\csname 雪\endcsname.^^J}
+  \message{\expandafter\meaning\csname \Uchar"96EA\endcsname.^^J}%
+  \count4095=0
+  \count4095=`🍌 \relax
+  \message{^^JC: \the\count4095^^J}
+  \def\🍌{banana}
+  \count4095=`\🍌 \relax
+  \message{D: \the\count4095. 🍌\string\🍌 \🍌^^J}
+  \message{\expandafter\meaning\csname 🍌\endcsname.^^J}
+  \message{\expandafter\meaning\csname \Uchar"1F34C\endcsname.^^J}%
+%--
+  \setbox0=\vbox{} % no dvi/xdv/pdf output
+\endgroup
+\end
diff --git a/source/texk/web2c/mplibdir/ChangeLog b/source/texk/web2c/mplibdir/ChangeLog
index 2082cbf59..728957b23 100644
--- a/source/texk/web2c/mplibdir/ChangeLog
+++ b/source/texk/web2c/mplibdir/ChangeLog
@@ -1,3 +1,9 @@
+2024-05-19   Luigi Scarso <luigi.scarso@gmail.com>
+        * Sync with https://github.com/ascherer/mplibdir commit c21f82c1990d1cdb86f51a00b5c81d0088e12454.
+
+2024-05-18   Luigi Scarso <luigi.scarso@gmail.com>
+        * Several patches for CWEB from Andreas Scherer
+
 2024-05-01   Luigi Scarso <luigi.scarso@gmail.com>
         * Fixed Update |arc| and |t_tot| after |do_arc_test| has just returned |t| 
           in mp_get_arc_time
diff --git a/source/texk/web2c/mplibdir/mp.w b/source/texk/web2c/mplibdir/mp.w
index 3392aa9f7..5003eebde 100644
--- a/source/texk/web2c/mplibdir/mp.w
+++ b/source/texk/web2c/mplibdir/mp.w
@@ -22,8 +22,8 @@
 
 \def\(#1){} % this is used to make section names sort themselves better
 \def\9#1{} % this is used for sort keys in the index via @@:sort key}{entry@@>
-\def\title{MetaPost}
-\pdfoutput=1
+\def\title{\MP}
+\pdfoutput=1 \sanitizecommand\MP{MetaPost}
 \pageno=3
 
 @* Introduction.
@@ -32,7 +32,7 @@ This is \MP\ by John Hobby, a graphics-language processor based on D. E. Knuth's
 
 Much of the original Pascal version of this program was copied with
 permission from MF.web Version 1.9. It interprets a language very
-similar to D.E. Knuth's METAFONT, but with changes designed to make it
+similar to D.E. Knuth's \MF, but with changes designed to make it
 more suitable for PostScript output.
 
 The main purpose of the following program is to explain the algorithms of \MP\
@@ -75,12 +75,12 @@ undergoes any modifications, so that it will be clear which version of
 @d true 1
 @d false 0
 
-@<Metapost version header@>=
+@<\MP\ version header@>=
 #define metapost_version "2.11"
 
 @ The external library header for \MP\ is |mplib.h|. It contains a
 few typedefs and the header defintions for the externally used
-fuctions.
+functions.
 
 The most important of the typedefs is the definition of the structure
 |MP_options|, that acts as a small, configurable front-end to the fairly
@@ -93,14 +93,14 @@ large |MP_instance| structure.
 #ifndef HAVE_BOOLEAN
 typedef int boolean;
 #endif
-@<Metapost version header@>
+@<\MP\ version header@>@;
 typedef struct MP_instance *MP;
-@<Exported types@>
+@<Exported types@>@;
 typedef struct MP_options {
-  @<Option variables@>
+  @<Option variables@>@;
 } MP_options;
-@<Exported function headers@>
-@<MPlib header stuff@>
+@<Exported function headers@>@;
+@<MPlib header stuff@>@;
 #endif
 
 @ The internal header file is much longer: it not only lists the complete
@@ -127,8 +127,8 @@ typedef int boolean;
 typedef int integer;
 #define MPOST_ABS abs
 #else
-/* See source/texk/web2c/w2c/config.h */
-#if INTEGER_MAX == LONG_MAX /* this should mean |INTEGER_TYPE| == long */
+/* See \.{source/texk/web2c/w2c/config.h} */
+#if INTEGER_MAX == LONG_MAX /* this should mean |INTEGER_TYPE == long| */
 #ifdef HAVE_LABS
 #define MPOST_ABS labs
 #else
@@ -136,44 +136,44 @@ typedef int integer;
 #endif
 #else
 #define MPOST_ABS abs
-#endif /* if |INTEGER_TYPE| == long */
-#endif /* ifndef |INTEGER_TYPE| */
+#endif /* |if INTEGER_TYPE == long| */
+#endif /* |ifndef INTEGER_TYPE| */
 
 
-@<Declare helpers@>;
-@<Enumeration types@>;
-@<Types in the outer block@>;
-@<Constants in the outer block@>;
+@<Declare helpers@>@;
+@<Enumeration types@>@;
+@<Types in the outer block@>@;
+@<Constants in the outer block@>@;
 typedef struct MP_instance {
-  @<Option variables@>
-  @<Global variables@>
+  @<Option variables@>@;
+  @<Global variables@>@;
 } MP_instance;
-@<Internal library declarations@>
-@<MPlib internal header stuff@>
+@<Internal library declarations@>@;
+@<MPlib internal header stuff@>@;
 #endif
 
 @ @c
 /*\#define DEBUGENVELOPE */
 #ifdef DEBUGENVELOPE
 static int DEBUGENVELOPECOUNTER=0;
-#define dbg_str(A)	  printf("\n--[==[%03d DEBUGENVELOPE ]==] %s",		   DEBUGENVELOPECOUNTER++, #A)
-#define dbg_n(A) 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%s, ",	   DEBUGENVELOPECOUNTER++, #A, number_tostring(A))
-#define dbg_in(A) 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%d, ",	   DEBUGENVELOPECOUNTER++, #A, (int)(A))
-#define dbg_dn(A) 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%.100f, ",DEBUGENVELOPECOUNTER++, #A, (double)(A))
-#define dbg_key(A) 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']= ",	   DEBUGENVELOPECOUNTER++, #A)
-#define dbg_key_nval(K,V) printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%s",	   DEBUGENVELOPECOUNTER++, #K,number_tostring(V))
-#define dbg_key_ival(K,V) printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%d",	   DEBUGENVELOPECOUNTER++, #K,(int)(V))
-#define dbg_key_dval(K,V) printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%.100f",  DEBUGENVELOPECOUNTER++, #K,(double)(V))
-#define dbg_comment(A) 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] --[==[%s]==]",   DEBUGENVELOPECOUNTER++, #A)
-#define dbg_sp 		  printf("\n--[==[%03d DEBUGENVELOPE ]==]  ",   	   DEBUGENVELOPECOUNTER++)
-#define dbg_open_t 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] {",   	   DEBUGENVELOPECOUNTER++)
-#define dbg_close_t 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] }",   	   DEBUGENVELOPECOUNTER++)
-#define dbg_comma 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] ,",   	   DEBUGENVELOPECOUNTER++)
-#define dbg_nl 		  printf("\n--[==[%03d DEBUGENVELOPE ]==] \n",   	   DEBUGENVELOPECOUNTER++)
+#define dbg_str(A)	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] %s",		   DEBUGENVELOPECOUNTER++, #A)@]
+#define dbg_n(A) 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%s, ",	   DEBUGENVELOPECOUNTER++, #A, number_tostring(A))@]
+#define dbg_in(A) 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%d, ",	   DEBUGENVELOPECOUNTER++, #A, (int)(A))@]
+#define dbg_dn(A) 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%.100f, ",DEBUGENVELOPECOUNTER++, #A, (double)(A))@]
+#define dbg_key(A) 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']= ",	   DEBUGENVELOPECOUNTER++, #A)@]
+#define dbg_key_nval(K,V) @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%s",	   DEBUGENVELOPECOUNTER++, #K,number_tostring(V))@]
+#define dbg_key_ival(K,V) @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%d",	   DEBUGENVELOPECOUNTER++, #K,(int)(V))@]
+#define dbg_key_dval(K,V) @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%.100f",  DEBUGENVELOPECOUNTER++, #K,(double)(V))@]
+#define dbg_comment(A) 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] --[==[%s]==]",   DEBUGENVELOPECOUNTER++, #A)@]
+#define dbg_sp 		  @[printf("\n--[==[%03d DEBUGENVELOPE ]==]  ",   	   DEBUGENVELOPECOUNTER++)@]
+#define dbg_open_t 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] {",   	   DEBUGENVELOPECOUNTER++)@]
+#define dbg_close_t 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] }",   	   DEBUGENVELOPECOUNTER++)@]
+#define dbg_comma 	  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] ,",   	   DEBUGENVELOPECOUNTER++)@]
+#define dbg_nl 		  @[printf("\n--[==[%03d DEBUGENVELOPE ]==] \n",   	   DEBUGENVELOPECOUNTER++)@]
 #define dbg_CUBIC         dbg_n(p->x_coord); dbg_n(p->y_coord); \
 			  dbg_n(p->right_x); dbg_n(p->right_y); \
 			  dbg_n(q->left_x);  dbg_n(q->left_y);  \
-			  dbg_n(q->x_coord); dbg_n(q->y_coord)
+			  dbg_n(q->x_coord); dbg_n(q->y_coord)@;
 #endif
 #define KPATHSEA_DEBUG_H 1
 #include <w2c/config.h>
@@ -186,26 +186,36 @@ static int DEBUGENVELOPECOUNTER=0;
 #ifdef HAVE_UNISTD_H
 #  include <unistd.h>           /* for access */
 #endif
-#include <time.h>               /* for struct tm \& co */
-#include <zlib.h>               /* for |ZLIB_VERSION|, zlibVersion() */
+#include <time.h>               /* for |struct tm| $\AND$ co */
+#include <zlib.h>               /* for |ZLIB_VERSION|, |zlibVersion()| */
 #include <png.h>                /* for |PNG_LIBPNG_VER_STRING|, |png_libpng_ver| */
-/*\#include <pixman.h>*/             /* for |PIXMAN_VERSION_STRING|, |pixman_version_string()| */
-/*\#include <cairo.h>*/              /* for |CAIRO_VERSION_STRING|, |cairo_version_string()| */
-/*\#include <gmp.h>*/                /* for |gmp_version| */
-/*\#include <mpfr.h>*/               /* for |MPFR_VERSION_STRING|, |mpfr_get_version()| */
+/*|
+#include <pixman.h>| */             /* for |PIXMAN_VERSION_STRING|, |pixman_version_string()| */
+/*|
+#include <cairo.h>| */              /* for |CAIRO_VERSION_STRING|, |cairo_version_string()| */
+/*|
+#include <gmp.h>| */                /* for |gmp_version| */
+/*|
+#include <mpfr.h>| */               /* for |MPFR_VERSION_STRING|, |mpfr_get_version()| */
 #include "mplib.h"
 #include "mplibps.h"            /* external header */
-/*\#include "mplibsvg.h" */          /* external header */
-/*\#include "mplibpng.h" */          /* external header */
+/*|
+#include "mplibsvg.h"| */          /* external header */
+/*|
+#include "mplibpng.h"| */          /* external header */
 #include "mpmp.h"               /* internal header */
 #include "mppsout.h"            /* internal header */
-/*\#include "mpsvgout.h"*/           /* internal header */
-/*\#include "mppngout.h"*/           /* internal header */
+/*|
+#include "mpsvgout.h"| */           /* internal header */
+/*|
+#include "mppngout.h"| */           /* internal header */
 #include "mpmath.h"             /* internal header */
 #include "mpmathdouble.h"       /* internal header */
 #include "mpmathdecimal.h"      /* internal header */
-/*|#include "mpmathbinary.h"|*/       /* internal header */
-/*|#include "mpmathinterval.h"|*/       /* internal header */
+/*|
+#include "mpmathbinary.h"| */       /* internal header */
+/*|
+#include "mpmathinterval.h"| */       /* internal header */
 #include "mpstrings.h"          /* internal header */
 /* BEGIN PATCH */
 mp_number dx_ap;    /* approximation of dx */
@@ -243,11 +253,12 @@ extern void mp_svg_backend_free (MP mp);
 extern int mp_svg_ship_out (mp_edge_object  *hh, int prologues);
 extern int mp_svg_gr_ship_out (mp_edge_object  *hh, int prologues, int standalone);
 
-@ @c
-extern font_number mp_read_font_info (MP mp, char *fname);      /* tfmin.w */
-@h @<Declarations@>;
-@<Basic printing procedures@>;
-@<Error handling procedures@>
+@ @s font_number int @c
+extern font_number mp_read_font_info (MP mp, char *fname);      /* \.{tfmin.w} */
+@h
+@<Declarations@>@;
+@<Basic printing procedures@>@;
+@<Error handling procedures@>@;
 
 @ Some debugging support for development. The trick with the variadic macros
 probably only works in gcc, as this preprocessor feature was not formalized
@@ -258,25 +269,25 @@ most compilers understand the non-debug version.
 @<MPlib internal header stuff@>=
 /*\#define DEBUG 2*/
 #if DEBUG
-#define debug_number(A) printf("%d: %s=%.32f (%d)\n", __LINE__, #A, number_to_double(A), number_to_scaled(A))
+#define debug_number(A) @[printf("%d: %s=%.32f (%d)\n", __LINE__, #A, number_to_double(A), number_to_scaled(A))@]
 #else
-#define debug_number(A)
+#define debug_number(A) @[@]
 #endif
 #if DEBUG>1
 void do_debug_printf(MP mp, const char *prefix, const char *fmt, ...);
-#  define debug_printf(a1,a2,a3) do_debug_printf(mp, "", a1,a2,a3)
-#  define FUNCTION_TRACE1(a1) do_debug_printf(mp, "FTRACE: ", a1)
-#  define FUNCTION_TRACE2(a1,a2) do_debug_printf(mp, "FTRACE: ", a1,a2)
-#  define FUNCTION_TRACE3(a1,a2,a3) do_debug_printf(mp, "FTRACE: ", a1,a2,a3)
-#  define FUNCTION_TRACE3X(a1,a2,a3) (void)mp
-#  define FUNCTION_TRACE4(a1,a2,a3,a4) do_debug_printf(mp, "FTRACE: ", a1,a2,a3,a4)
+#  define debug_printf(a1,a2,a3) @[do_debug_printf(mp, "", a1,a2,a3)@]
+#  define FUNCTION_TRACE1(a1) do_@[debug_printf(mp, "FTRACE: ", a1)@]
+#  define FUNCTION_TRACE2(a1,a2) @[do_debug_printf(mp, "FTRACE: ", a1,a2)@]
+#  define FUNCTION_TRACE3(a1,a2,a3) @[do_debug_printf(mp, "FTRACE: ", a1,a2,a3)@]
+#  define FUNCTION_TRACE3X(a1,a2,a3) @[(void)mp@]
+#  define FUNCTION_TRACE4(a1,a2,a3,a4) @[do_debug_printf(mp, "FTRACE: ", a1,a2,a3,a4)@]
 #else
-#  define debug_printf(a1,a2,a3)
-#  define FUNCTION_TRACE1(a1) (void)mp
-#  define FUNCTION_TRACE2(a1,a2) (void)mp
-#  define FUNCTION_TRACE3(a1,a2,a3) (void)mp
-#  define FUNCTION_TRACE3X(a1,a2,a3) (void)mp
-#  define FUNCTION_TRACE4(a1,a2,a3,a4) (void)mp
+#  define debug_printf(a1,a2,a3) @[@]
+#  define FUNCTION_TRACE1(a1) @[(void)mp@]
+#  define FUNCTION_TRACE2(a1,a2) @[(void)mp@]
+#  define FUNCTION_TRACE3(a1,a2,a3) @[(void)mp@]
+#  define FUNCTION_TRACE3X(a1,a2,a3) @[(void)mp@]
+#  define FUNCTION_TRACE4(a1,a2,a3,a4) @[(void)mp@]
 #endif
 
 @ This function occasionally crashes (if something is written after the
@@ -284,19 +295,16 @@ log file is already closed), but that is not so important while debugging.
 
 @c
 #if DEBUG
-void do_debug_printf(MP mp, const char *prefix, const char *fmt, ...) ;
 void do_debug_printf(MP mp, const char *prefix, const char *fmt, ...) {
   va_list ap;
-#if 0
   va_start (ap, fmt);
+#if 0
   if (mp->log_file && !ferror((FILE *)mp->log_file)) {
     fputs(prefix, mp->log_file);
     vfprintf(mp->log_file, fmt, ap);
   }
   va_end(ap);
-#endif
   va_start (ap, fmt);
-#if 0
   if (mp->term_out  && !ferror((FILE *)mp->term_out)) {
 #else
   if (false) {
@@ -308,8 +316,11 @@ void do_debug_printf(MP mp, const char *prefix, const char *fmt, ...) {
     vfprintf(stdout, fmt, ap);
   }
   va_end(ap);
-}
+#if 0
+  }
 #endif
+}
+#endif /* |if DEBUG| */
 
 @ Here are the functions that set up the \MP\ instance.
 
@@ -333,6 +344,8 @@ MP_options *mp_options (void) {
 |left_point| and |right_point| of a number |a| simply return |a|, while
 |interval_set| of the pair |(a,b)|  returns the mid point.
 
+@s mp_number int
+
 @<Declarations@>=
 static void mp_stub_m_get_left_endpoint(MP mp, mp_number * r, mp_number a);
 static void mp_stub_m_get_right_endpoint(MP mp, mp_number * r, mp_number a);
@@ -364,11 +377,11 @@ static void mp_stub_m_interval_set(MP mp, mp_number * r, mp_number a, mp_number
 
 @ The whole instance structure is initialized with zeroes,
 this greatly reduces the number of statements needed in
-the |Allocate or initialize variables| block.
+the |@<Allocate or ...@>| block.
 
 @d set_callback_option(A) do { mp->A = mp_##A;
   if (opt->A!=NULL) mp->A = opt->A;
-} while (0)
+} while (0)@;
 
 @c
 static MP mp_do_new (jmp_buf * buf) {
@@ -387,9 +400,8 @@ static MP mp_do_new (jmp_buf * buf) {
 static void mp_free (MP mp) {
   int k;        /* loop variable */
   @<Dealloc variables@>;
-  if (mp->noninteractive) {
-    @<Finish non-interactive use@>;
-  }
+  if (mp->noninteractive)
+    @<Finish non-interactive use@>@;
   xfree (mp->jump_buf);
   @<Free table entries@>;
   free_math();
@@ -431,72 +443,72 @@ typedef struct mp_number_data {
 typedef struct mp_number_data mp_number;
 #define is_number(A) ((A).type != mp_nan_type)
 
-typedef void (*convert_func) (mp_number *r);
-typedef void (*m_log_func) (MP mp, mp_number *r, mp_number a);
-typedef void (*m_exp_func) (MP mp, mp_number *r, mp_number a);
-typedef void (*m_unif_rand_func) (MP mp, mp_number *ret, mp_number x_orig);
-typedef void (*m_norm_rand_func) (MP mp, mp_number *ret);
-typedef void (*pyth_add_func) (MP mp, mp_number *r, mp_number a, mp_number b);
-typedef void (*pyth_sub_func) (MP mp, mp_number *r, mp_number a, mp_number b);
-typedef void (*n_arg_func) (MP mp, mp_number *r, mp_number a, mp_number b);
-typedef void (*velocity_func) (MP mp, mp_number *r, mp_number a, mp_number b, mp_number c, mp_number d, mp_number e);
-typedef void (*ab_vs_cd_func) (MP mp, mp_number *r, mp_number a, mp_number b, mp_number c, mp_number d);
-typedef void (*crossing_point_func) (MP mp, mp_number *r, mp_number a, mp_number b, mp_number c);
-typedef void (*number_from_int_func) (mp_number *A, int B);
-typedef void (*number_from_boolean_func) (mp_number *A, int B);
-typedef void (*number_from_scaled_func) (mp_number *A, int B);
-typedef void (*number_from_double_func) (mp_number *A, double B);
-typedef void (*number_from_addition_func) (mp_number *A, mp_number B, mp_number C);
-typedef void (*number_from_substraction_func) (mp_number *A, mp_number B, mp_number C);
-typedef void (*number_from_div_func) (mp_number *A, mp_number B, mp_number C);
-typedef void (*number_from_mul_func) (mp_number *A, mp_number B, mp_number C);
-typedef void (*number_from_int_div_func) (mp_number *A, mp_number B, int C);
-typedef void (*number_from_int_mul_func) (mp_number *A, mp_number B, int C);
-typedef void (*number_from_oftheway_func) (MP mp, mp_number *A, mp_number t, mp_number B, mp_number C);
-typedef void (*number_negate_func) (mp_number *A);
-typedef void (*number_add_func) (mp_number *A, mp_number B);
-typedef void (*number_substract_func) (mp_number *A, mp_number B);
-typedef void (*number_modulo_func) (mp_number *A, mp_number B);
-typedef void (*number_half_func) (mp_number *A);
-typedef void (*number_halfp_func) (mp_number *A);
-typedef void (*number_double_func) (mp_number *A);
-typedef void (*number_abs_func) (mp_number *A);
-typedef void (*number_clone_func) (mp_number *A, mp_number B);
-typedef void (*number_swap_func) (mp_number *A, mp_number *B);
-typedef void (*number_add_scaled_func) (mp_number *A, int b);
-typedef void (*number_multiply_int_func) (mp_number *A, int b);
-typedef void (*number_divide_int_func) (mp_number *A, int b);
-typedef int (*number_to_int_func) (mp_number A);
-typedef int (*number_to_boolean_func) (mp_number A);
-typedef int (*number_to_scaled_func) (mp_number A);
-typedef int (*number_round_func) (mp_number A);
-typedef void (*number_floor_func) (mp_number *A);
-typedef double (*number_to_double_func) (mp_number A);
-typedef int (*number_odd_func) (mp_number A);
-typedef int (*number_equal_func) (mp_number A, mp_number B);
-typedef int (*number_less_func) (mp_number A, mp_number B);
-typedef int (*number_greater_func) (mp_number A, mp_number B);
-typedef int (*number_nonequalabs_func) (mp_number A, mp_number B);
-typedef void (*make_scaled_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
-typedef void (*make_fraction_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
-typedef void (*take_fraction_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
-typedef void (*take_scaled_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
-typedef void (*sin_cos_func) (MP mp, mp_number A, mp_number *S, mp_number *C);
-typedef void (*slow_add_func) (MP mp, mp_number *A, mp_number S, mp_number C);
-typedef void (*sqrt_func) (MP mp, mp_number *ret, mp_number A);
-typedef void (*init_randoms_func) (MP mp, int seed);
-typedef void (*new_number_func) (MP mp, mp_number *A, mp_number_type t);
-typedef void (*free_number_func) (MP mp, mp_number *n);
-typedef void (*fraction_to_round_scaled_func) (mp_number *n);
-typedef void (*print_func) (MP mp, mp_number A);
+typedef void @[@] (*convert_func) (mp_number *r);
+typedef void @[@] (*m_log_func) (MP mp, mp_number *r, mp_number a);
+typedef void @[@] (*m_exp_func) (MP mp, mp_number *r, mp_number a);
+typedef void @[@] (*m_unif_rand_func) (MP mp, mp_number *ret, mp_number x_orig);
+typedef void @[@] (*m_norm_rand_func) (MP mp, mp_number *ret);
+typedef void @[@] (*pyth_add_func) (MP mp, mp_number *r, mp_number a, mp_number b);
+typedef void @[@] (*pyth_sub_func) (MP mp, mp_number *r, mp_number a, mp_number b);
+typedef void @[@] (*n_arg_func) (MP mp, mp_number *r, mp_number a, mp_number b);
+typedef void @[@] (*velocity_func) (MP mp, mp_number *r, mp_number a, mp_number b, mp_number c, mp_number d, mp_number e);
+typedef void @[@] (*ab_vs_cd_func) (MP mp, mp_number *r, mp_number a, mp_number b, mp_number c, mp_number d);
+typedef void @[@] (*crossing_point_func) (MP mp, mp_number *r, mp_number a, mp_number b, mp_number c);
+typedef void @[@] (*number_from_int_func) (mp_number *A, int B);
+typedef void @[@] (*number_from_boolean_func) (mp_number *A, int B);
+typedef void @[@] (*number_from_scaled_func) (mp_number *A, int B);
+typedef void @[@] (*number_from_double_func) (mp_number *A, double B);
+typedef void @[@] (*number_from_addition_func) (mp_number *A, mp_number B, mp_number C);
+typedef void @[@] (*number_from_substraction_func) (mp_number *A, mp_number B, mp_number C);
+typedef void @[@] (*number_from_div_func) (mp_number *A, mp_number B, mp_number C);
+typedef void @[@] (*number_from_mul_func) (mp_number *A, mp_number B, mp_number C);
+typedef void @[@] (*number_from_int_div_func) (mp_number *A, mp_number B, int C);
+typedef void @[@] (*number_from_int_mul_func) (mp_number *A, mp_number B, int C);
+typedef void @[@] (*number_from_oftheway_func) (MP mp, mp_number *A, mp_number t, mp_number B, mp_number C);
+typedef void @[@] (*number_negate_func) (mp_number *A);
+typedef void @[@] (*number_add_func) (mp_number *A, mp_number B);
+typedef void @[@] (*number_substract_func) (mp_number *A, mp_number B);
+typedef void @[@] (*number_modulo_func) (mp_number *A, mp_number B);
+typedef void @[@] (*number_half_func) (mp_number *A);
+typedef void @[@] (*number_halfp_func) (mp_number *A);
+typedef void @[@] (*number_double_func) (mp_number *A);
+typedef void @[@] (*number_abs_func) (mp_number *A);
+typedef void @[@] (*number_clone_func) (mp_number *A, mp_number B);
+typedef void @[@] (*number_swap_func) (mp_number *A, mp_number *B);
+typedef void @[@] (*number_add_scaled_func) (mp_number *A, int b);
+typedef void @[@] (*number_multiply_int_func) (mp_number *A, int b);
+typedef void @[@] (*number_divide_int_func) (mp_number *A, int b);
+typedef int @[@] (*number_to_int_func) (mp_number A);
+typedef int @[@] (*number_to_boolean_func) (mp_number A);
+typedef int @[@] (*number_to_scaled_func) (mp_number A);
+typedef int @[@] (*number_round_func) (mp_number A);
+typedef void @[@] (*number_floor_func) (mp_number *A);
+typedef double @[@] (*number_to_double_func) (mp_number A);
+typedef int @[@] (*number_odd_func) (mp_number A);
+typedef int @[@] (*number_equal_func) (mp_number A, mp_number B);
+typedef int @[@] (*number_less_func) (mp_number A, mp_number B);
+typedef int @[@] (*number_greater_func) (mp_number A, mp_number B);
+typedef int @[@] (*number_nonequalabs_func) (mp_number A, mp_number B);
+typedef void @[@] (*make_scaled_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
+typedef void @[@] (*make_fraction_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
+typedef void @[@] (*take_fraction_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
+typedef void @[@] (*take_scaled_func) (MP mp, mp_number *ret, mp_number A, mp_number B);
+typedef void @[@] (*sin_cos_func) (MP mp, mp_number A, mp_number *S, mp_number *C);
+typedef void @[@] (*slow_add_func) (MP mp, mp_number *A, mp_number S, mp_number C);
+typedef void @[@] (*sqrt_func) (MP mp, mp_number *ret, mp_number A);
+typedef void @[@] (*init_randoms_func) (MP mp, int seed);
+typedef void @[@] (*new_number_func) (MP mp, mp_number *A, mp_number_type t);
+typedef void @[@] (*free_number_func) (MP mp, mp_number *n);
+typedef void @[@] (*fraction_to_round_scaled_func) (mp_number *n);
+typedef void @[@] (*print_func) (MP mp, mp_number A);
 typedef char * (*tostring_func) (MP mp, mp_number A);
-typedef void (*scan_func) (MP mp, int A);
-typedef void (*mp_free_func) (MP mp);
-typedef void (*set_precision_func) (MP mp);
+typedef void @[@] (*scan_func) (MP mp, int A);
+typedef void @[@] (*mp_free_func) (MP mp);
+typedef void @[@] (*set_precision_func) (MP mp);
 /* math interval new primitives */
-typedef void (*m_get_left_endpoint_func) (MP mp, mp_number *r, mp_number a);
-typedef void (*m_get_right_endpoint_func) (MP mp, mp_number *r, mp_number a);
-typedef void (*m_interval_set_func) (MP mp, mp_number *r, mp_number a, mp_number b);
+typedef void @[@] (*m_get_left_endpoint_func) (MP mp, mp_number *r, mp_number a);
+typedef void @[@] (*m_get_right_endpoint_func) (MP mp, mp_number *r, mp_number a);
+typedef void @[@] (*m_interval_set_func) (MP mp, mp_number *r, mp_number a, mp_number b);
 
 typedef struct math_data {
   mp_number precision_default;
@@ -642,11 +654,9 @@ MP mp_initialize (MP_options * opt) {
   }
   if (opt->command_line && *(opt->command_line))
     mp->command_line = xstrdup (opt->command_line);
-  if (mp->noninteractive) {
-    @<Prepare function pointers for non-interactive use@>;
-  }
-  /* open the terminal for output */
-  t_open_out();
+  if (mp->noninteractive)
+    @<Prepare function pointers for non-interactive use@>@;
+  t_open_out(); /* open the terminal for output */
 #if DEBUG
   setvbuf(stdout, (char *) NULL, _IONBF, 0);
   setvbuf(mp->term_out, (char *) NULL, _IONBF, 0);
@@ -678,7 +688,7 @@ MP mp_initialize (MP_options * opt) {
     mp_snprintf (ss, 256, "Ouch---my internal constants have been clobbered!\n"
                  "---case %i", (int) mp->bad);
     mp_fputs ((char *) ss, mp->err_out);
-@.Ouch...clobbered@>;
+@.Ouch...clobbered@>
     return mp;
   }
   mp_do_initialize (mp);        /* erase preloaded mem */
@@ -764,7 +774,9 @@ approaches to the problem of understanding a somewhat complicated system.
 strange behavior that sometimes occurs when \MP\ is being installed or
 when system wizards are fooling around with \MP\ without quite knowing
 what they are doing. Such code will not normally be compiled; it is
-delimited by the preprocessor test `|#ifdef DEBUG .. #endif|'.
+delimited by the preprocessor test|
+#ifdef DEBUG| $\ldots$|
+#endif|.
 
 @ The following parameters can be changed at compile time to extend or
 reduce \MP's capacity.
@@ -777,7 +789,7 @@ reduce \MP's capacity.
 @ Like the preceding parameters, the following quantities can be changed
 to extend or reduce \MP's capacity.
 
-@ @<Glob...@>=
+@<Glob...@>=
 int pool_size;  /* maximum number of characters in strings, including all
                    error messages and help texts, and the names of all identifiers */
 int max_in_open;        /* maximum number of input files and error insertions that
@@ -798,8 +810,7 @@ int utf8_mode;
 @ @<Dealloc variables@>=
 xfree (mp->banner);
 
-@
-@d set_lower_limited_value(a,b,c) do { a=c; if (b>c) a=b; } while (0)
+@ @d set_lower_limited_value(a,b,c) do { a=c; if (b>c) a=b; } while (0)@;
 
 @<Allocate or ...@>=
 mp->param_size = 4;
@@ -827,7 +838,7 @@ integer bad;    /* is some ``constant'' wrong? */
 @ Later on we will say `|if ( int_packets+(17+2)*int_increment>bistack_size )mp->bad=19;|',
 or something similar.
 
-In case you are wondering about the non-consequtive values of |bad|: most
+In case you are wondering about the non-consecutive values of |bad|: most
 of the things that used to be WEB constants are now runtime variables
 with checking at assignment time.
 
@@ -877,8 +888,8 @@ the user's external character set by means of arrays |xord| and |xchr|
 that are analogous to Pascal's |ord| and |chr| functions.
 
 @<MPlib internal header stuff@>=
-#define xchr(A) mp->xchr[(A)]
-#define xord(A) mp->xord[(A)]
+#define xchr(A) @[mp->xchr[(A)]@]
+#define xord(A) @[mp->xord[(A)]@]
 
 @ @<Glob...@>=
 ASCII_code xord[256];   /* specifies conversion of input characters */
@@ -966,7 +977,7 @@ enum mp_filetype {
   mp_filetype_postscript,       /* the postscript output */
   mp_filetype_bitmap,           /* the bitmap output file */
   mp_filetype_memfile,          /* memory dumps, obsolete */
-  mp_filetype_metrics,          /* TeX font metric files */
+  mp_filetype_metrics,          /* \TeX\ font metric files */
   mp_filetype_fontmap,          /* PostScript font mapping files */
   mp_filetype_font,             /*  PostScript type1 font programs */
   mp_filetype_encoding,         /*  PostScript font encoding files */
@@ -977,12 +988,12 @@ typedef char *(*mp_script_runner) (MP, const char *, size_t);
 typedef char *(*mp_text_maker) (MP, const char *, size_t, int);
 typedef void *(*mp_file_opener) (MP, const char *, const char *, int);
 typedef char *(*mp_file_reader) (MP, void *, size_t *);
-typedef void (*mp_binfile_reader) (MP, void *, void **, size_t *);
-typedef void (*mp_file_closer) (MP, void *);
-typedef int (*mp_file_eoftest) (MP, void *);
-typedef void (*mp_file_flush) (MP, void *);
-typedef void (*mp_file_writer) (MP, void *, const char *);
-typedef void (*mp_binfile_writer) (MP, void *, void *, size_t);
+typedef void @[@] (*mp_binfile_reader) (MP, void *, void **, size_t *);
+typedef void @[@] (*mp_file_closer) (MP, void *);
+typedef int @[@] (*mp_file_eoftest) (MP, void *);
+typedef void @[@] (*mp_file_flush) (MP, void *);
+typedef void @[@] (*mp_file_writer) (MP, void *, const char *);
+typedef void @[@] (*mp_binfile_writer) (MP, void *, void *, size_t);
 
 @ @<Option variables@>=
 mp_file_finder find_file;
@@ -1137,7 +1148,7 @@ static char *mp_read_ascii_file (MP mp, void *ff, size_t * size) {
   char *s = NULL;
   FILE *f = (FILE *) ff;
   *size = 0;
-  (void) mp;                    /* for -Wunused */
+  (void) mp;                    /* for \.{-Wunused} */
   if (f == NULL)
     return NULL;
   c = fgetc (f);
@@ -1314,7 +1325,7 @@ to the input buffer.  The variable |command_line| will be filled by the
 @d t_open_out()  do {/* open the terminal for text output */
     mp->term_out = (mp->open_file)(mp,"terminal", "w", mp_filetype_terminal);
     mp->err_out = (mp->open_file)(mp,"error", "w", mp_filetype_error);
-} while (0)
+} while (0)@;
 @d t_open_in()  do { /* open the terminal for text input */
     mp->term_in = (mp->open_file)(mp,"terminal", "r", mp_filetype_terminal);
     if (mp->command_line!=NULL) {
@@ -1327,7 +1338,7 @@ to the input buffer.  The variable |command_line| will be filled by the
     } else {
 	  mp->last = 0;
     }
-} while (0)
+} while (0)@;
 
 @<Option variables@>=
 char *command_line;
@@ -1347,9 +1358,9 @@ these operations can be specified:
 @^system dependencies@>
 
 @<MPlib internal header stuff@>=
-#define update_terminal()  (mp->flush_file)(mp,mp->term_out)      /* empty the terminal output buffer */
-#define clear_terminal()          /* clear the terminal input buffer */
-#define wake_up_terminal() (mp->flush_file)(mp,mp->term_out)
+#define update_terminal()  @[(mp->flush_file)(mp,mp->term_out)@]      /* empty the terminal output buffer */
+#define clear_terminal()   @[@]   /* clear the terminal input buffer */
+#define wake_up_terminal() @[(mp->flush_file)(mp,mp->term_out)@]
                     /* cancel the user's cancellation of output */
 
 @ We need a special routine to read the first line of \MP\ input from
@@ -1409,12 +1420,12 @@ boolean mp_init_terminal (MP mp) {                               /* gets the ter
     if (!mp->noninteractive) {
       wake_up_terminal();
       mp_fputs ("**", mp->term_out);
-@.**@>;
+@.**@>
       update_terminal();
     }
     if (!mp_input_ln (mp, mp->term_in)) {       /* this shouldn't happen */
       mp_fputs ("\n! End of file on the terminal... why?", mp->term_out);
-@.End of file on the terminal@>;
+@.End of file on the terminal@>
       return false;
     }
     loc = (halfword) mp->first;
@@ -1593,14 +1604,14 @@ by changing |wterm|, |wterm_ln|, and |wterm_cr| here.
 @^system dependencies@>
 
 @<MPlib internal header stuff@>=
-#define mp_fputs(b,f) (mp->write_ascii_file)(mp,f,b)
-#define wterm(A)     mp_fputs((A), mp->term_out)
+#define mp_fputs(b,f) @[(mp->write_ascii_file)(mp,f,b)@]
+#define wterm(A)     @[mp_fputs((A), mp->term_out)@]
 #define wterm_chr(A) { unsigned char ss[2]; ss[0]=(A); ss[1]='\0'; wterm((char *)ss);}
-#define wterm_cr     mp_fputs("\n", mp->term_out)
+#define wterm_cr     @[mp_fputs("\n", mp->term_out)@]
 #define wterm_ln(A)  { wterm_cr; mp_fputs((A), mp->term_out); }
-#define wlog(A)        mp_fputs((A), mp->log_file)
+#define wlog(A)      @[mp_fputs((A), mp->log_file)@]
 #define wlog_chr(A)  { unsigned char ss[2]; ss[0]=(A); ss[1]='\0'; wlog((char *)ss);}
-#define wlog_cr      mp_fputs("\n", mp->log_file)
+#define wlog_cr      @[mp_fputs("\n", mp->log_file)@]
 #define wlog_ln(A)   { wlog_cr; mp_fputs((A), mp->log_file); }
 
 
@@ -1668,11 +1679,11 @@ static void mp_print_visible_char (MP mp, ASCII_code s) {
     if (mp->term_offset == (unsigned) mp->max_print_line) {
       wterm_cr;
       mp->term_offset = 0;
-    };
+    }
     if (mp->file_offset == (unsigned) mp->max_print_line) {
       wlog_cr;
       mp->file_offset = 0;
-    };
+    }
     break;
   case log_only:
     wlog_chr (xchr (s));
@@ -1756,7 +1767,7 @@ static void mp_do_print (MP mp, const char *ss, size_t len) {
   } else {
     size_t j = 0;
     while (j < len) {
-      /* this was |xord((int)ss[j])| but that doesnt work */
+      /* this was |xord((int)ss[j])| but that doesn't work */
       mp_print_char (mp, (ASCII_code) ss[j]);
       j++;
     }
@@ -1764,8 +1775,7 @@ static void mp_do_print (MP mp, const char *ss, size_t len) {
 }
 
 
-@
-@<Basic print...@>=
+@ @<Basic print...@>=
 void mp_print (MP mp, const char *ss) {
   assert (ss != NULL);
   mp_do_print (mp, ss, strlen (ss));
@@ -1871,7 +1881,7 @@ This procedure is never called when |interaction<mp_scroll_mode|.
       mp_print(mp, (A));
     }
     mp_term_input(mp);
-  } while (0) /* prints a string and gets a line of input */
+  } while (0)@; /* prints a string and gets a line of input */
 
 @c
 void mp_term_input (MP mp) {                               /* gets a line from the terminal */
@@ -1943,7 +1953,7 @@ where |error| is not called at all.
 @<Declarations@>=
 static void mp_print_err (MP mp, const char *A);
 
-@ @c
+@ @s line x @c
 static void mp_print_err (MP mp, const char *A) {
   if (mp->interaction == mp_error_stop_mode)
     wake_up_terminal();
@@ -2040,14 +2050,14 @@ whole program. It is used when there is no recovery from a particular error.
 
 The program uses a |jump_buf| to handle this, this is initialized at three
 spots: the start of |mp_new|, the start of |mp_initialize|, and the start
-of |mp_run|. Those are the only library enty points.
+of |mp_run|. Those are the only library entry points.
 @^system dependencies@>
 
 @<Glob...@>=
 jmp_buf *jump_buf;
 
 @ If the array of internals is still |NULL| when |jump_out| is called, a
-crash occured during initialization, and it is not safe to run the normal
+crash occurred during initialization, and it is not safe to run the normal
 cleanup routine.
 
 @<Error hand...@>=
@@ -2060,9 +2070,7 @@ void mp_jump_out (MP mp) {
 @ @<Internal ...@>=
 void mp_jump_out (MP mp);
 
-@
-
-@<Error hand...@>=
+@ @<Error hand...@>=
 void mp_warn (MP mp, const char *msg) {
   unsigned saved_selector = mp->selector;
   mp_normalize_selector (mp);
@@ -2083,6 +2091,8 @@ Individual lines of help are recorded in the array |help_line|, which
 contains entries in positions |0..(help_ptr-1)|. They should be printed
 in reverse order, i.e., with |help_line[0]| appearing last.
 
+@s mp_sym int
+
 @c
 void mp_error (MP mp, const char *msg, const char **hlp, boolean deletions_allowed) {
   ASCII_code c; /* what the user types */
@@ -2118,7 +2128,7 @@ void mp_error (MP mp, const char *msg, const char **hlp, boolean deletions_allow
   incr (mp->error_count);
   if (mp->error_count == 100) {
     mp_print_nl (mp, "(That makes 100 errors; please try again.)");
-@.That makes 100 errors...@>;
+@.That makes 100 errors...@>
     mp->history = mp_fatal_error_stop;
     mp_jump_out (mp);
   }
@@ -2136,7 +2146,7 @@ while (true) {
 CONTINUE:
   mp_clear_for_error_prompt (mp);
   prompt_input ("? ");
-@.?\relax@>;
+@.?\relax@>
   if (mp->last == mp->first)
     return;
   c = mp->buffer[mp->first];
@@ -2155,7 +2165,7 @@ edited and the relevant line number.
 @^system dependencies@>
 
 @<Exported types@>=
-typedef void (*mp_editor_cmd) (MP, char *, int);
+typedef void @[@] (*mp_editor_cmd) (MP, char *, int);
 
 @ @<Option variables@>=
 mp_editor_cmd run_editor;
@@ -2175,9 +2185,7 @@ void mp_run_editor (MP mp, char *fname, int fline) {
 }
 
 
-@
-
-@<Interpret code |c| and |return| if done@>=
+@ @<Interpret code |c| and |return| if done@>=
 switch (c) {
 case '0':
 case '1':
@@ -2227,7 +2235,7 @@ default:
 @ @<Print the menu...@>=
 {
   mp_print (mp, "Type <return> to proceed, S to scroll future error messages,");
-@.Type <return> to proceed...@>;
+@.Type <return> to proceed...@>
   mp_print_nl (mp, "R to run without stopping, Q to run quietly,");
   mp_print_nl (mp, "I to insert something, ");
   if (mp->file_ptr > 0)
@@ -2304,7 +2312,7 @@ to be familiar with \MP's input stacks.
     mp_get_next (mp);           /* one-level recursive call of |error| is possible */
     @<Decrease the string reference count, if the current token is a string@>;
     c--;
-  };
+  }
   set_cur_cmd (s1);
   set_cur_mod (s2);
   set_cur_sym (s3);
@@ -2337,7 +2345,7 @@ in a row.
       mp_print (mp, help_line[help_ptr]);
       mp_print_ln (mp);
     } while (help_ptr != 0);
-  };
+  }
   help_ptr=4;
   help_line[3] = "Sorry, I already gave what help I could...";
   help_line[2] = "Maybe you should try asking a human?";
@@ -2360,7 +2368,7 @@ in a row.
     else {
       j++;
       mp_print_char (mp, xord ('%'));
-    };
+    }
     j++;
   }
 }
@@ -2379,7 +2387,7 @@ if (mp->use_err_help) {
   while (help_ptr > 0) {
     decr (help_ptr);
     mp_print_nl (mp, help_line[help_ptr]);
-  };
+  }
   mp_print_ln (mp);
   if (! mp->noninteractive) {
    if (mp->interaction > mp_batch_mode)
@@ -2439,7 +2447,7 @@ void mp_overflow (MP mp, const char *s, integer n) {
          NULL };
   mp_normalize_selector (mp);
   mp_snprintf (msg, 256, "MetaPost capacity exceeded, sorry [%s=%d]", s, (int) n);
-@.MetaPost capacity exceeded ...@>;
+@.MetaPost capacity exceeded ...@>
   if ( mp->interaction==mp_error_stop_mode )
     mp->interaction=mp_scroll_mode; /* no more interaction */
   if ( mp->log_opened )
@@ -2471,12 +2479,12 @@ void mp_confusion (MP mp, const char *s) {
   mp_normalize_selector (mp);
   if (mp->history < mp_error_message_issued) {
     mp_snprintf (msg, 256, "This can't happen (%s)", s);
-@.This can't happen@>;
+@.This can't happen@>
     hlp[0] = "I'm broken. Please show this to someone who can fix can fix";
     hlp[1] = NULL;
   } else {
     mp_snprintf (msg, 256, "I can\'t go on meeting you like this");
-@.I can't go on...@>;
+@.I can't go on...@>
   }
   if ( mp->interaction==mp_error_stop_mode )
     mp->interaction=mp_scroll_mode; /* no more interaction */
@@ -2524,7 +2532,7 @@ static void mp_pause_for_instructions (MP mp) {
     mp->interaction = mp_error_stop_mode;
     if ((mp->selector == log_only) || (mp->selector == no_print))
       incr (mp->selector);
-@.Interruption@>;
+@.Interruption@>
     mp_error (mp, "Interruption", hlp, false);
     mp->interrupt = 0;
   }
@@ -2569,7 +2577,7 @@ an arithmetic error has been detected.
 @d check_arith() do {
   if ( mp->arith_error )
     mp_clear_arith(mp);
-} while (0)
+} while (0)@;
 
 @c
 static void mp_clear_arith (MP mp) {
@@ -2580,7 +2588,7 @@ static void mp_clear_arith (MP mp) {
          "tactics next time. But I shall try to carry on anyway.",
          NULL };
   mp_error (mp, "Arithmetic overflow", hlp, true);
-@.Arithmetic overflow@>;
+@.Arithmetic overflow@>
   mp->arith_error = false;
 }
 
@@ -2650,7 +2658,7 @@ The global variable |j_random| tells which element has most recently
 been consumed.
 The global variable |random_seed| was introduced in version 0.9,
 for the sole reason of stressing the fact that the initial value of the
-random seed is system-dependant. The initialization code below will initialize
+random seed is system-dependent. The initialization code below will initialize
 this variable to |(internal[mp_time] div unity)+internal[mp_day]|, but this
 is not good enough on modern fast machines that are capable of running
 multiple MetaPost processes within the same second.
@@ -2706,18 +2714,20 @@ void mp_new_randoms (MP mp) {
 
 @ To consume a random fraction, the program below will say `|next_random|'.
 Now each number system has its own implementation,
-true to the original as much as possibile.
+true to the original as much as possible.
+
+Unused.
 
 @c
-/* Unused.
-static void mp\_next\_random (MP mp, mp\_number *ret) {
-  if ( mp->j\_random==0 )
-    mp\_new\_randoms(mp);
+#if 0
+static void mp_next_random (MP mp, mp_number *ret) {
+  if ( mp->j_random==0 )
+    mp_new_randoms(mp);
   else
-    decr(mp->j\_random);
-  number\_clone (*ret, mp->randoms[mp->j\_random]);
+    decr(mp->j_random);
+  number_clone (*ret, mp->randoms[mp->j_random]);
 }
-*/
+#endif
 
 @ To produce a uniform random number in the range |0<=u<x| or |0>=u>x|
 or |0=u=x|, given a |scaled| value~|x|, we proceed as shown here.
@@ -2729,87 +2739,88 @@ This is the original one,
 that stays as reference:
 As said before, now each number system has its own implementation.
 
+Unused.
 
 @c
-/*Unused.
-static void mp\_unif\_rand (MP mp, mp\_number *ret, mp\_number x\_orig) {
-  mp\_number y;     // trial value
-  mp\_number x, abs\_x;
-  mp\_number u;
-  new\_fraction (y);
-  new\_number (x);
-  new\_number (abs\_x);
-  new\_number (u);
-  number\_clone (x, x\_orig);
-  number\_clone (abs\_x, x);
-  number\_abs (abs\_x);
-  mp\_next\_random(mp, \&u);
-  take\_fraction (y, abs\_x, u);
-  free\_number (u);
-  if (number\_equal(y, abs\_x)) {
-    set\_number\_to\_zero(*ret);
-  } else if (number\_positive(x)) {
-    number\_clone (*ret, y);
+#if 0
+static void mp_unif_rand (MP mp, mp_number *ret, mp_number x_orig) {
+  mp_number y;     // trial value
+  mp_number x, abs_x;
+  mp_number u;
+  new_fraction (y);
+  new_number (x);
+  new_number (abs_x);
+  new_number (u);
+  number_clone (x, x_orig);
+  number_clone (abs_x, x);
+  number_abs (abs_x);
+  mp_next_random(mp, &u);
+  take_fraction (y, abs_x, u);
+  free_number (u);
+  if (number_equal(y, abs_x)) {
+    set_number_to_zero(*ret);
+  } else if (number_positive(x)) {
+    number_clone (*ret, y);
   } else {
-    number\_clone (*ret, y);
-    number\_negate (*ret);
+    number_clone (*ret, y);
+    number_negate (*ret);
   }
-  free\_number (abs\_x);
-  free\_number (x);
-  free\_number (y);
+  free_number (abs_x);
+  free_number (x);
+  free_number (y);
 }
-*/
+#endif
 
 @ Finally, a normal deviate with mean zero and unit standard deviation
 can readily be obtained with the ratio method (Algorithm 3.4.1R in
 {\sl The Art of Computer Programming\/}). This is the original one,
 that stays as reference:
 Now each number system has its own implementation,
-true to the original as much as possibile.
+true to the original as much as possible.
 
+ Unused.
 
 @c
-/*  Unused.
-static void mp\_norm\_rand (MP mp, mp\_number *ret) {
-  mp\_number ab\_vs\_cd;
-  mp\_number abs\_x;
-  mp\_number u;
-  mp\_number r;
-  mp\_number la, xa;
-  new\_number (ab\_vs\_cd);
-  new\_number (la);
-  new\_number (xa);
-  new\_number (abs\_x);
-  new\_number (u);
-  new\_number (r);
+#if 0
+static void mp_norm_rand (MP mp, mp_number *ret) {
+  mp_number ab_vs_cd;
+  mp_number abs_x;
+  mp_number u;
+  mp_number r;
+  mp_number la, xa;
+  new_number (ab_vs_cd);
+  new_number (la);
+  new_number (xa);
+  new_number (abs_x);
+  new_number (u);
+  new_number (r);
   do {
     do {
-      mp\_number v;
-      new\_number (v);
-      mp\_next\_random(mp, \&v);
-      number\_substract (v, fraction\_half\_t);
-      take\_fraction (xa, sqrt\_8\_e\_k, v);
-      free\_number (v);
-      mp\_next\_random(mp, \&u);
-      number\_clone (abs\_x, xa);
-      number\_abs (abs\_x);
-    } while (number\_greaterequal (abs\_x, u));
-    make\_fraction (r, xa, u);
-    number\_clone (xa, r);
-    m\_log (la, u);
-    set\_number\_from\_substraction(la, twelve\_ln\_2\_k, la);
-    ab\_vs\_cd (ab\_vs\_cd, one\_k, la, xa, xa);
-  } while (number\_negative(ab\_vs\_cd));
-  number\_clone (*ret, xa);
-  free\_number (ab\_vs\_cd);
-  free\_number (r);
-  free\_number (abs\_x);
-  free\_number (la);
-  free\_number (xa);
-  free\_number (u);
+      mp_number v;
+      new_number (v);
+      mp_next_random(mp, &v);
+      number_substract (v, fraction_half_t);
+      take_fraction (xa, sqrt_8_e_k, v);
+      free_number (v);
+      mp_next_random(mp, &u);
+      number_clone (abs_x, xa);
+      number_abs (abs_x);
+    } while (number_greaterequal (abs_x, u));
+    make_fraction (r, xa, u);
+    number_clone (xa, r);
+    m_log (la, u);
+    set_number_from_substraction(la, twelve_ln_2_k, la);
+    ab_vs_cd (ab_vs_cd, one_k, la, xa, xa);
+  } while (number_negative(ab_vs_cd));
+  number_clone (*ret, xa);
+  free_number (ab_vs_cd);
+  free_number (r);
+  free_number (abs_x);
+  free_number (la);
+  free_number (xa);
+  free_number (u);
 }
-*/
-
+#endif
 
 @* Packed data.
 
@@ -2826,6 +2837,9 @@ from quarterwords. These are legacy macros.
 @ The reader should study the following definitions closely:
 @^system dependencies@>
 
+@s mp_knot int
+@s mp_variable_type int
+
 @<Types...@>=
 typedef struct mp_value_node_data *mp_value_node;
 typedef struct mp_node_data *mp_node;
@@ -2877,8 +2891,7 @@ int math_mode;               /* math mode */
 @ @<Allocate or initialize ...@>=
 mp->math_mode = opt->math_mode;
 
-@
-@d xfree(A) do { mp_xfree(A); A=NULL; } while (0)
+@ @d xfree(A) do { mp_xfree(A); A=NULL; } while (0)@;
 @d xrealloc(P,A,B) mp_xrealloc(mp,P,(size_t)A,B)
 @d xmalloc(A,B)  mp_xmalloc(mp,(size_t)A,B)
 @d xstrdup(A)  mp_xstrdup(mp,A)
@@ -2954,7 +2967,6 @@ while (mp->knot_nodes) {
 
 @d malloc_node(A) do_alloc_node(mp,(A))
 
-@
 @c
 void *do_alloc_node (MP mp, size_t size) {
     void *p;
@@ -3000,7 +3012,7 @@ void *mp_xmalloc (MP mp, size_t nmem, size_t size) {
     mp_jump_out (mp);
   }
 #endif
-  w = calloc(nmem, size); /* TODO: check an un-initialize use of w and replace calloc with malloc. */
+  w = calloc(nmem, size); /* TODO: check an un-initialized use of |w| and replace |calloc| with |malloc|. */
   if (w == NULL) {
     mp_fputs ("Out of memory!\n", mp->err_out);
     mp->history = mp_system_error_stop;
@@ -3020,6 +3032,9 @@ can readily be transported into environments that do not have automatic
 facilities for strings, garbage collection, etc., and so that it can be in
 control of what error messages the user receives.
 
+@s mp_name_type_type int
+@s mp_node_data int
+
 @d MP_VOID (mp_node)(1) /* |NULL+1|, a |NULL| pointer different from |NULL| */
 
 @d mp_link(A)      (A)->link /* the |link| field of a node */
@@ -3027,18 +3042,19 @@ control of what error messages the user receives.
    mp_node d = (B);
    /* |printf("set link    of %p to %p on line %d\n", (A), d, __LINE__);| */
    mp_link((A)) = d;
- } while (0)
+ } while (0)@;
 @d mp_type(A)      (A)->type /* identifies what kind of value this is */
 @d mp_name_type(A) (A)->name_type /* a clue to the name of this value */
 
-@ @<MPlib internal header stuff@>=
+@<MPlib internal header stuff@>=
 #define NODE_BODY                       \
   mp_variable_type type;                \
   mp_name_type_type name_type;          \
   unsigned short has_number;		\
-  struct mp_node_data *link
+  struct mp_node_data *link@;
+@#@t\2\2\4\4@>
 typedef struct mp_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_value_data data;
 } mp_node_data;
 typedef struct mp_node_data *mp_symbolic_node;
@@ -3050,7 +3066,7 @@ can use the special features that keep track of current and maximum memory usage
 @d add_var_used(a) do {
    mp->var_used+=(a);
    if (mp->var_used>mp->var_used_max) mp->var_used_max=mp->var_used;
-} while (0)
+} while (0)@;
 
 @<Glob...@>=
 size_t var_used;        /* how much memory is in use */
@@ -3060,10 +3076,10 @@ size_t var_used_max;    /* how much memory was in use max */
 
 @c
 #if DEBUG
-#define mp_sym_info(A)       get_mp_sym_info(mp,(A))
-#define set_mp_sym_info(A,B) do_set_mp_sym_info(mp,(A),(B))
-#define mp_sym_sym(A)        get_mp_sym_sym(mp,(A))
-#define set_mp_sym_sym(A,B)  do_set_mp_sym_sym(mp,(A),(mp_sym)(B))
+#define mp_sym_info(A)       @[get_mp_sym_info(mp,(A))@]
+#define set_mp_sym_info(A,B) @[do_set_mp_sym_info(mp,(A),(B))@]
+#define mp_sym_sym(A)        @[get_mp_sym_sym(mp,(A))@]
+#define set_mp_sym_sym(A,B)  @[do_set_mp_sym_sym(mp,(A),(mp_sym)(B))@]
 static void do_set_mp_sym_info (MP mp, mp_node p, halfword v) {
   FUNCTION_TRACE3 ("do_set_mp_sym_info(%p,%d)\n", p, v);
   assert (p->type == mp_symbol_node);
@@ -3087,10 +3103,10 @@ static mp_sym get_mp_sym_sym (MP mp, mp_node p) {
   return pp->data.sym;
 }
 #else
-#define mp_sym_info(A)        indep_value(A)
-#define set_mp_sym_info(A,B)  set_indep_value(A, (B))
-#define mp_sym_sym(A)        (A)->data.sym
-#define set_mp_sym_sym(A,B)  (A)->data.sym = (mp_sym)(B)
+#define mp_sym_info(A)        @[indep_value(A)@]
+#define set_mp_sym_info(A,B)  @[set_indep_value(A, (B))@]
+#define mp_sym_sym(A)        @[(A)->data.sym@]
+#define set_mp_sym_sym(A,B)  @[(A)->data.sym = (mp_sym)(B)@]
 #endif
 
 @ @<Declarations@>=
@@ -3194,6 +3210,8 @@ void mp_free_value_node (MP mp, mp_node p);
 Some nodes are created statically, since static allocation is
 more efficient than dynamic allocation when we can get away with it.
 
+@s mp_dash_node int
+
 @<Glob...@>=
 mp_dash_node null_dash;
 mp_value_node dep_head;
@@ -3371,7 +3389,7 @@ mp_semicolon, /* the operator `\.;', must be |comma+1| */
 mp_end_group, /* end a group (\&{endgroup}), must be |semicolon+1| */
 mp_stop, /* end a job (\&{end}, \&{dump}), must be |end_group+1| */
 mp_outer_tag, /* protection code added to command code */
-mp_undefined_cs, /* protection code added to command code */
+mp_undefined_cs,@[@] /* protection code added to command code */
 } mp_command_code;
 
 @ Variables and capsules in \MP\ have a variety of ``types,''
@@ -3436,7 +3454,7 @@ typedef enum {
   mp_dash_node_type,
   mp_dep_node_type,
   mp_if_node_type,
-  mp_edge_header_node_type,
+  mp_edge_header_node_type,@[@]
 } mp_variable_type;
 
 @ @<Declarations@>=
@@ -3759,7 +3777,7 @@ mp_glyph_infont, /* operation code for \.{glyph} */
 mp_kern_flag, /* operation code for \.{kern} */
 mp_m_get_left_endpoint_op, /* math interval new primitives  operation code for \.{interval\_get\_left\_endpoint} */
 mp_m_get_right_endpoint_op, /* math interval new primitives operation code for \.{interval\_get\_right\_endpoint} */
-mp_interval_set_op, /* math interval new primitives operation code for \.{interval\_set} */
+mp_interval_set_op,@[@] /* math interval new primitives operation code for \.{interval\_set} */
 
 
 @ @c
@@ -4106,7 +4124,7 @@ enum mp_given_internal {
   mp_output_format_options,     /* the output format options set up by \&{outputformatoptions} */
   mp_number_system,             /* the number system as set up by \&{numbersystem} */
   mp_number_precision,          /* the number system precision as set up by \&{numberprecision} */
-  mp_job_name,                  /* the perceived jobname, as set up from the options stucture,
+  mp_job_name,                  /* the perceived jobname, as set up from the options structure,
                                    the name of the input file, or by \&{jobname}  */
   mp_tracing_titles,            /* show titles online when they appear */
   mp_tracing_equations,         /* show each variable when it becomes known */
@@ -4146,10 +4164,10 @@ enum mp_given_internal {
   mp_true_corners,              /* positive to make \&{llcorner} etc. ignore \&{setbounds} */
   mp_default_color_model,       /* the default color model for unspecified items */
   mp_restore_clip_color,
-  mp_procset,                   /* wether or not create PostScript command shortcuts */
+  mp_procset,                   /* whether or not create PostScript command shortcuts */
   mp_hppp,                      /* horizontal pixels per point (for png output) */
   mp_vppp,                      /* vertical pixels per point (for png output) */
-  mp_gtroffmode,                /* whether the user specified |-troff| on the command line */
+  mp_gtroffmode,@[@]            /* whether the user specified \.{-troff} on the command line */
 };
 typedef struct {
   mp_value v;
@@ -4158,16 +4176,16 @@ typedef struct {
 
 
 @ @<MPlib internal header stuff@>=
-#define internal_value(A) mp->internal[(A)].v.data.n
+#define internal_value(A) @[mp->internal[(A)].v.data.n@]
 #define set_internal_from_number(A,B) do { \
   number_clone (internal_value ((A)),(B));\
-} while (0)
-#define internal_string(A) (mp_string)mp->internal[(A)].v.data.str
-#define set_internal_string(A,B) mp->internal[(A)].v.data.str=(B)
-#define internal_name(A) mp->internal[(A)].intname
-#define set_internal_name(A,B) mp->internal[(A)].intname=(B)
-#define internal_type(A) (mp_variable_type)mp->internal[(A)].v.type
-#define set_internal_type(A,B) mp->internal[(A)].v.type=(B)
+} while (0)@;
+#define internal_string(A) @[(mp_string)mp->internal[(A)].v.data.str@]
+#define set_internal_string(A,B) @[mp->internal[(A)].v.data.str=(B)@]
+#define internal_name(A) @[mp->internal[(A)].intname@]
+#define set_internal_name(A,B) @[mp->internal[(A)].intname=(B)@]
+#define internal_type(A) @[(mp_variable_type)mp->internal[(A)].v.type@]
+#define set_internal_type(A,B) @[mp->internal[(A)].v.type=(B)@]
 #define set_internal_from_cur_exp(A) do { \
   if (internal_type ((A)) == mp_string_type) { \
       add_str_ref (cur_exp_str ()); \
@@ -4175,13 +4193,11 @@ typedef struct {
   } else { \
       set_internal_from_number ((A), cur_exp_value_number ()); \
   } \
-} while (0)
-
+} while (0)@;
 
 
-@
 
-@d max_given_internal mp_gtroffmode
+@ @d max_given_internal mp_gtroffmode
 
 @<Glob...@>=
 mp_internal *internal;  /* the values of internal quantities */
@@ -4232,103 +4248,103 @@ anywhere else.
 
 @<Put each of \MP's primitives into the hash table@>=
 mp_primitive (mp, "tracingtitles", mp_internal_quantity, mp_tracing_titles);
-@:tracingtitles_}{\&{tracingtitles} primitive@>;
+@:tracingtitles_}{\&{tracingtitles} primitive@>
 mp_primitive (mp, "tracingequations", mp_internal_quantity, mp_tracing_equations);
-@:mp_tracing_equations_}{\&{tracingequations} primitive@>;
+@:mp_tracing_equations_}{\&{tracingequations} primitive@>
 mp_primitive (mp, "tracingcapsules", mp_internal_quantity, mp_tracing_capsules);
-@:mp_tracing_capsules_}{\&{tracingcapsules} primitive@>;
+@:mp_tracing_capsules_}{\&{tracingcapsules} primitive@>
 mp_primitive (mp, "tracingchoices", mp_internal_quantity, mp_tracing_choices);
-@:mp_tracing_choices_}{\&{tracingchoices} primitive@>;
+@:mp_tracing_choices_}{\&{tracingchoices} primitive@>
 mp_primitive (mp, "tracingspecs", mp_internal_quantity, mp_tracing_specs);
-@:mp_tracing_specs_}{\&{tracingspecs} primitive@>;
+@:mp_tracing_specs_}{\&{tracingspecs} primitive@>
 mp_primitive (mp, "tracingcommands", mp_internal_quantity, mp_tracing_commands);
-@:mp_tracing_commands_}{\&{tracingcommands} primitive@>;
+@:mp_tracing_commands_}{\&{tracingcommands} primitive@>
 mp_primitive (mp, "tracingrestores", mp_internal_quantity, mp_tracing_restores);
-@:mp_tracing_restores_}{\&{tracingrestores} primitive@>;
+@:mp_tracing_restores_}{\&{tracingrestores} primitive@>
 mp_primitive (mp, "tracingmacros", mp_internal_quantity, mp_tracing_macros);
-@:mp_tracing_macros_}{\&{tracingmacros} primitive@>;
+@:mp_tracing_macros_}{\&{tracingmacros} primitive@>
 mp_primitive (mp, "tracingoutput", mp_internal_quantity, mp_tracing_output);
-@:mp_tracing_output_}{\&{tracingoutput} primitive@>;
+@:mp_tracing_output_}{\&{tracingoutput} primitive@>
 mp_primitive (mp, "tracingstats", mp_internal_quantity, mp_tracing_stats);
-@:mp_tracing_stats_}{\&{tracingstats} primitive@>;
+@:mp_tracing_stats_}{\&{tracingstats} primitive@>
 mp_primitive (mp, "tracinglostchars", mp_internal_quantity, mp_tracing_lost_chars);
-@:mp_tracing_lost_chars_}{\&{tracinglostchars} primitive@>;
+@:mp_tracing_lost_chars_}{\&{tracinglostchars} primitive@>
 mp_primitive (mp, "tracingonline", mp_internal_quantity, mp_tracing_online);
-@:mp_tracing_online_}{\&{tracingonline} primitive@>;
+@:mp_tracing_online_}{\&{tracingonline} primitive@>
 mp_primitive (mp, "year", mp_internal_quantity, mp_year);
-@:mp_year_}{\&{year} primitive@>;
+@:mp_year_}{\&{year} primitive@>
 mp_primitive (mp, "month", mp_internal_quantity, mp_month);
-@:mp_month_}{\&{month} primitive@>;
+@:mp_month_}{\&{month} primitive@>
 mp_primitive (mp, "day", mp_internal_quantity, mp_day);
-@:mp_day_}{\&{day} primitive@>;
+@:mp_day_}{\&{day} primitive@>
 mp_primitive (mp, "time", mp_internal_quantity, mp_time);
-@:time_}{\&{time} primitive@>;
+@:time_}{\&{time} primitive@>
 mp_primitive (mp, "hour", mp_internal_quantity, mp_hour);
-@:hour_}{\&{hour} primitive@>;
+@:hour_}{\&{hour} primitive@>
 mp_primitive (mp, "minute", mp_internal_quantity, mp_minute);
-@:minute_}{\&{minute} primitive@>;
+@:minute_}{\&{minute} primitive@>
 mp_primitive (mp, "charcode", mp_internal_quantity, mp_char_code);
-@:mp_char_code_}{\&{charcode} primitive@>;
+@:mp_char_code_}{\&{charcode} primitive@>
 mp_primitive (mp, "charext", mp_internal_quantity, mp_char_ext);
-@:mp_char_ext_}{\&{charext} primitive@>;
+@:mp_char_ext_}{\&{charext} primitive@>
 mp_primitive (mp, "charwd", mp_internal_quantity, mp_char_wd);
-@:mp_char_wd_}{\&{charwd} primitive@>;
+@:mp_char_wd_}{\&{charwd} primitive@>
 mp_primitive (mp, "charht", mp_internal_quantity, mp_char_ht);
-@:mp_char_ht_}{\&{charht} primitive@>;
+@:mp_char_ht_}{\&{charht} primitive@>
 mp_primitive (mp, "chardp", mp_internal_quantity, mp_char_dp);
-@:mp_char_dp_}{\&{chardp} primitive@>;
+@:mp_char_dp_}{\&{chardp} primitive@>
 mp_primitive (mp, "charic", mp_internal_quantity, mp_char_ic);
-@:mp_char_ic_}{\&{charic} primitive@>;
+@:mp_char_ic_}{\&{charic} primitive@>
 mp_primitive (mp, "designsize", mp_internal_quantity, mp_design_size);
-@:mp_design_size_}{\&{designsize} primitive@>;
+@:mp_design_size_}{\&{designsize} primitive@>
 mp_primitive (mp, "pausing", mp_internal_quantity, mp_pausing);
-@:mp_pausing_}{\&{pausing} primitive@>;
+@:mp_pausing_}{\&{pausing} primitive@>
 mp_primitive (mp, "showstopping", mp_internal_quantity, mp_showstopping);
-@:mp_showstopping_}{\&{showstopping} primitive@>;
+@:mp_showstopping_}{\&{showstopping} primitive@>
 mp_primitive (mp, "fontmaking", mp_internal_quantity, mp_fontmaking);
-@:mp_fontmaking_}{\&{fontmaking} primitive@>;
+@:mp_fontmaking_}{\&{fontmaking} primitive@>
 mp_primitive (mp, "texscriptmode", mp_internal_quantity, mp_texscriptmode);
-@:mp_texscriptmode_}{\&{texscriptmode} primitive@>;
+@:mp_texscriptmode_}{\&{texscriptmode} primitive@>
 mp_primitive (mp, "linejoin", mp_internal_quantity, mp_linejoin);
-@:mp_linejoin_}{\&{linejoin} primitive@>;
+@:mp_linejoin_}{\&{linejoin} primitive@>
 mp_primitive (mp, "linecap", mp_internal_quantity, mp_linecap);
-@:mp_linecap_}{\&{linecap} primitive@>;
+@:mp_linecap_}{\&{linecap} primitive@>
 mp_primitive (mp, "miterlimit", mp_internal_quantity, mp_miterlimit);
-@:mp_miterlimit_}{\&{miterlimit} primitive@>;
+@:mp_miterlimit_}{\&{miterlimit} primitive@>
 mp_primitive (mp, "warningcheck", mp_internal_quantity, mp_warning_check);
-@:mp_warning_check_}{\&{warningcheck} primitive@>;
+@:mp_warning_check_}{\&{warningcheck} primitive@>
 mp_primitive (mp, "boundarychar", mp_internal_quantity, mp_boundary_char);
-@:mp_boundary_char_}{\&{boundarychar} primitive@>;
+@:mp_boundary_char_}{\&{boundarychar} primitive@>
 mp_primitive (mp, "prologues", mp_internal_quantity, mp_prologues);
-@:mp_prologues_}{\&{prologues} primitive@>;
+@:mp_prologues_}{\&{prologues} primitive@>
 mp_primitive (mp, "truecorners", mp_internal_quantity, mp_true_corners);
-@:mp_true_corners_}{\&{truecorners} primitive@>;
+@:mp_true_corners_}{\&{truecorners} primitive@>
 mp_primitive (mp, "mpprocset", mp_internal_quantity, mp_procset);
-@:mp_procset_}{\&{mpprocset} primitive@>;
+@:mp_procset_}{\&{mpprocset} primitive@>
 mp_primitive (mp, "troffmode", mp_internal_quantity, mp_gtroffmode);
-@:troffmode_}{\&{troffmode} primitive@>;
+@:troffmode_}{\&{troffmode} primitive@>
 mp_primitive (mp, "defaultcolormodel", mp_internal_quantity, mp_default_color_model);
-@:mp_default_color_model_}{\&{defaultcolormodel} primitive@>;
+@:mp_default_color_model_}{\&{defaultcolormodel} primitive@>
 mp_primitive (mp, "restoreclipcolor", mp_internal_quantity, mp_restore_clip_color);
-@:mp_restore_clip_color_}{\&{restoreclipcolor} primitive@>;
+@:mp_restore_clip_color_}{\&{restoreclipcolor} primitive@>
 mp_primitive (mp, "outputtemplate", mp_internal_quantity, mp_output_template);
-@:mp_output_template_}{\&{outputtemplate} primitive@>;
+@:mp_output_template_}{\&{outputtemplate} primitive@>
 mp_primitive (mp, "outputfilename", mp_internal_quantity, mp_output_filename);
-@:mp_output_filename_}{\&{outputfilename} primitive@>;
+@:mp_output_filename_}{\&{outputfilename} primitive@>
 mp_primitive (mp, "numbersystem", mp_internal_quantity, mp_number_system);
-@:mp_number_system_}{\&{numbersystem} primitive@>;
+@:mp_number_system_}{\&{numbersystem} primitive@>
 mp_primitive (mp, "numberprecision", mp_internal_quantity, mp_number_precision);
-@:mp_number_precision_}{\&{numberprecision} primitive@>;
+@:mp_number_precision_}{\&{numberprecision} primitive@>
 mp_primitive (mp, "outputformat", mp_internal_quantity, mp_output_format);
-@:mp_output_format_}{\&{outputformat} primitive@>;
+@:mp_output_format_}{\&{outputformat} primitive@>
 mp_primitive (mp, "outputformatoptions", mp_internal_quantity, mp_output_format_options);
-@:mp_output_format_options_}{\&{outputformatoptions} primitive@>;
+@:mp_output_format_options_}{\&{outputformatoptions} primitive@>
 mp_primitive (mp, "jobname", mp_internal_quantity, mp_job_name);
 @:mp_job_name_}{\&{jobname} primitive@>
 mp_primitive (mp, "hppp", mp_internal_quantity, mp_hppp);
-@:mp_hppp_}{\&{hppp} primitive@>;
+@:mp_hppp_}{\&{hppp} primitive@>
 mp_primitive (mp, "vppp", mp_internal_quantity, mp_vppp);
-@:mp_vppp_}{\&{vppp} primitive@>;
+@:mp_vppp_}{\&{vppp} primitive@>
 
 
 @ Colors can be specified in four color models. In the special
@@ -4519,9 +4535,7 @@ void mp_end_diagnostic (MP mp, boolean blank_line) {
 }
 
 
-@
-
-@<Glob...@>=
+@ @<Glob...@>=
 unsigned int old_setting;
 
 @ We will occasionally use |begin_diagnostic| in connection with line-number
@@ -4561,7 +4575,7 @@ class numbers in nonstandard extensions of \MP.
 @d invalid_class 20 /* bad character in the input */
 @d max_class 20 /* the largest class number */
 
-@d semicolon_class 6 /* the ; */
+@d semicolon_class 6 /* the class number of `\.;' */
 
 @<Glob...@>=
 #define digit_class 0 /* the class number of \.{0123456789} */
@@ -4633,38 +4647,38 @@ that holds the current command value of the token, and an
 @d set_text(A)     do {
    FUNCTION_TRACE3 ("set_text(%p, %p)\n",(A),(B));
    (A)->text=(B) ;
-} while (0)
+} while (0)@;
 
 @d set_eq_type(A,B)  do {
    FUNCTION_TRACE3 ("set_eq_type(%p, %d)\n",(A),(B));
    (A)->type=(B) ;
-} while (0)
+} while (0)@;
 
 @d set_equiv(A,B)  do {
    FUNCTION_TRACE3 ("set_equiv(%p, %d)\n",(A),(B));
    (A)->v.data.node=NULL ;
    (A)->v.data.indep.serial=(B);
-} while (0)
+} while (0)@;
 
 @d set_equiv_node(A,B)  do {
    FUNCTION_TRACE3 ("set_equiv_node(%p, %p)\n",(A),(B));
    (A)->v.data.node=(B) ;
    (A)->v.data.indep.serial=0;
-} while (0)
+} while (0)@;
 
 @d set_equiv_sym(A,B)  do {
    FUNCTION_TRACE3 ("set_equiv_sym(%p, %p)\n",(A),(B));
    (A)->v.data.node=(mp_node)(B);
    (A)->v.data.indep.serial=0;
-} while (0)
+} while (0)@;
 
 @ @c
 #if DEBUG
-#define text(A)         do_get_text(mp, (A))
-#define eq_type(A)      do_get_eq_type(mp, (A))
-#define equiv(A)        do_get_equiv(mp, (A))
-#define equiv_node(A)   do_get_equiv_node(mp, (A))
-#define equiv_sym(A)    do_get_equiv_sym(mp, (A))
+#define text(A)         @[do_get_text(mp, (A))@]
+#define eq_type(A)      @[do_get_eq_type(mp, (A))@]
+#define equiv(A)        @[do_get_equiv(mp, (A))@]
+#define equiv_node(A)   @[do_get_equiv_node(mp, (A))@]
+#define equiv_sym(A)    @[do_get_equiv_sym(mp, (A))@]
 static mp_string do_get_text (MP mp, mp_sym A) {
   FUNCTION_TRACE3 ("%d = do_get_text(%p)\n",A->text,A);
   return A->text;
@@ -4686,11 +4700,11 @@ static mp_sym do_get_equiv_sym (MP mp, mp_sym A) {
   return (mp_sym)A->v.data.node;
 }
 #else
-#define text(A)         (A)->text
-#define eq_type(A)      (A)->type
-#define equiv(A)        (A)->v.data.indep.serial
-#define equiv_node(A)   (A)->v.data.node
-#define equiv_sym(A)    (mp_sym)(A)->v.data.node
+#define text(A)         @[(A)->text@]
+#define eq_type(A)      @[(A)->type@]
+#define equiv(A)        @[(A)->v.data.indep.serial@]
+#define equiv_node(A)   @[(A)->v.data.node@]
+#define equiv_sym(A)    @[(mp_sym)(A)->v.data.node@]
 #endif
 
 @ @<Declarations...@>=
@@ -4710,7 +4724,7 @@ typedef struct mp_symbol_entry {
   void *parent;
 } mp_symbol_entry;
 
-@ @<Glob...@>=
+@ @s avl_tree int @<Glob...@>=
 integer st_count;       /* total number of known identifiers */
 avl_tree symbols;       /* avl tree of symbolic tokens */
 avl_tree frozen_symbols;        /* avl tree of frozen symbolic tokens */
@@ -4890,7 +4904,7 @@ static mp_sym mp_frozen_id_lookup (MP mp, char *j, size_t l,
   return mp_do_id_lookup (mp, mp->frozen_symbols, j, l, insert_new);
 }
 
-/* see mp\_print\_sym  (mp\_sym sym) */
+/* see |mp_print_sym (mp_sym sym)| */
 @ Get a numeric value from \MP\ is not easy. We have to consider
 the macro and the loops, as also the internal type (this is a
 first attempt, and more work is needed). If we are inside
@@ -5017,7 +5031,7 @@ static mp_sym mp_frozen_primitive (MP mp, const char *ss, halfword c,
 
 @ This routine returns |true| if the argument is an un-redefinable symbol
 because it is one of the error recovery tokens (as explained elsewhere,
-|frozen_inaccessible| actuall is redefinable).
+|frozen_inaccessible| actually is redefinable).
 
 @c
 static boolean mp_is_frozen (MP mp, mp_sym sym) {
@@ -5034,99 +5048,97 @@ as follows:
 
 @<Put each of \MP's primitives into the hash table@>=
 mp_primitive (mp, "..", mp_path_join, 0);
-@:.._}{\.{..} primitive@>;
+@:.._}{\.{..} primitive@>
 mp_primitive (mp, "[", mp_left_bracket, 0);
 mp->frozen_left_bracket = mp_frozen_primitive (mp, "[", mp_left_bracket, 0);
-@:[ }{\.{[} primitive@>;
+@:[ }{\.{[} primitive@>
 mp_primitive (mp, "]", mp_right_bracket, 0);
-@:] }{\.{]} primitive@>;
+@:] }{\.{]} primitive@>
 mp_primitive (mp, "}", mp_right_brace, 0);
-@:]]}{\.{\char`\}} primitive@>;
+@:]]}{\.{\char`\}} primitive@>
 mp_primitive (mp, "{", mp_left_brace, 0);
-@:][}{\.{\char`\{} primitive@>;
+@:][}{\.{\char`\{} primitive@>
 mp_primitive (mp, ":", mp_colon, 0);
 mp->frozen_colon = mp_frozen_primitive (mp, ":", mp_colon, 0);
-@:: }{\.{:} primitive@>;
+@:: }{\.{:} primitive@>
 mp_primitive (mp, "::", mp_double_colon, 0);
-@::: }{\.{::} primitive@>;
+@::: }{\.{::} primitive@>
 mp_primitive (mp, "||:", mp_bchar_label, 0);
-@:::: }{\.{\char'174\char'174:} primitive@>;
+@:::: }{\.{\char'174\char'174:} primitive@>
 mp_primitive (mp, ":=", mp_assignment, 0);
-@::=_}{\.{:=} primitive@>;
+@::=_}{\.{:=} primitive@>
 mp_primitive (mp, ",", mp_comma, 0);
-@:, }{\., primitive@>;
+@:, }{\., primitive@>
 mp_primitive (mp, ";", mp_semicolon, 0);
 mp->frozen_semicolon = mp_frozen_primitive (mp, ";", mp_semicolon, 0);
-@:; }{\.; primitive@>;
+@:; }{\.; primitive@>
 mp_primitive (mp, "\\", mp_relax, 0);
-@:]]\\}{\.{\char`\\} primitive@>;
+@:]]\\}{\.{\char`\\} primitive@>
 mp_primitive (mp, "addto", mp_add_to_command, 0);
-@:add_to_}{\&{addto} primitive@>;
+@:add_to_}{\&{addto} primitive@>
 mp_primitive (mp, "atleast", mp_at_least, 0);
-@:at_least_}{\&{atleast} primitive@>;
-mp_primitive (mp, "begingroup", mp_begin_group, 0);
+@:at_least_}{\&{atleast} primitive@>
+mp_primitive (mp, "begingroup", mp_begin_group, 0); @+
 mp->bg_loc = cur_sym();
-@:begin_group_}{\&{begingroup} primitive@>;
+@:begin_group_}{\&{begingroup} primitive@>
 mp_primitive (mp, "controls", mp_controls, 0);
-@:controls_}{\&{controls} primitive@>;
+@:controls_}{\&{controls} primitive@>
 mp_primitive (mp, "curl", mp_curl_command, 0);
-@:curl_}{\&{curl} primitive@>;
+@:curl_}{\&{curl} primitive@>
 mp_primitive (mp, "delimiters", mp_delimiters, 0);
-@:delimiters_}{\&{delimiters} primitive@>;
-mp_primitive (mp, "endgroup", mp_end_group, 0);
+@:delimiters_}{\&{delimiters} primitive@>
+mp_primitive (mp, "endgroup", mp_end_group, 0); @+
 mp->eg_loc = cur_sym();
 mp->frozen_end_group = mp_frozen_primitive (mp, "endgroup", mp_end_group, 0);
-@:endgroup_}{\&{endgroup} primitive@>;
+@:endgroup_}{\&{endgroup} primitive@>
 mp_primitive (mp, "everyjob", mp_every_job_command, 0);
-@:every_job_}{\&{everyjob} primitive@>;
+@:every_job_}{\&{everyjob} primitive@>
 mp_primitive (mp, "exitif", mp_exit_test, 0);
-@:exit_if_}{\&{exitif} primitive@>;
+@:exit_if_}{\&{exitif} primitive@>
 mp_primitive (mp, "expandafter", mp_expand_after, 0);
-@:expand_after_}{\&{expandafter} primitive@>;
+@:expand_after_}{\&{expandafter} primitive@>
 mp_primitive (mp, "interim", mp_interim_command, 0);
-@:interim_}{\&{interim} primitive@>;
+@:interim_}{\&{interim} primitive@>
 mp_primitive (mp, "let", mp_let_command, 0);
-@:let_}{\&{let} primitive@>;
+@:let_}{\&{let} primitive@>
 mp_primitive (mp, "newinternal", mp_new_internal, 0);
-@:new_internal_}{\&{newinternal} primitive@>;
+@:new_internal_}{\&{newinternal} primitive@>
 mp_primitive (mp, "of", mp_of_token, 0);
-@:of_}{\&{of} primitive@>;
+@:of_}{\&{of} primitive@>
 mp_primitive (mp, "randomseed", mp_random_seed, 0);
-@:mp_random_seed_}{\&{randomseed} primitive@>;
+@:mp_random_seed_}{\&{randomseed} primitive@>
 mp_primitive (mp, "save", mp_save_command, 0);
-@:save_}{\&{save} primitive@>;
+@:save_}{\&{save} primitive@>
 mp_primitive (mp, "scantokens", mp_scan_tokens, 0);
-@:scan_tokens_}{\&{scantokens} primitive@>;
-
+@:scan_tokens_}{\&{scantokens} primitive@>
 mp_primitive (mp, "runscript", mp_runscript, 0);
-@:run_script_}{\&{runscript} primitive@>;
+@:run_script_}{\&{runscript} primitive@>
 mp_primitive (mp, "maketext", mp_maketext, 0);
-@:make_text_}{\&{maketext} primitive@>;
-
+@:make_text_}{\&{maketext} primitive@>
 mp_primitive (mp, "shipout", mp_ship_out_command, 0);
-@:ship_out_}{\&{shipout} primitive@>;
+@:ship_out_}{\&{shipout} primitive@>
 mp_primitive (mp, "skipto", mp_skip_to, 0);
-@:skip_to_}{\&{skipto} primitive@>;
+@:skip_to_}{\&{skipto} primitive@>
 mp_primitive (mp, "special", mp_special_command, 0);
-@:special}{\&{special} primitive@>;
+@:special}{\&{special} primitive@>
 mp_primitive (mp, "fontmapfile", mp_special_command, 1);
-@:fontmapfile}{\&{fontmapfile} primitive@>;
+@:fontmapfile}{\&{fontmapfile} primitive@>
 mp_primitive (mp, "fontmapline", mp_special_command, 2);
-@:fontmapline}{\&{fontmapline} primitive@>;
+@:fontmapline}{\&{fontmapline} primitive@>
 mp_primitive (mp, "step", mp_step_token, 0);
-@:step_}{\&{step} primitive@>;
+@:step_}{\&{step} primitive@>
 mp_primitive (mp, "str", mp_str_op, 0);
-@:str_}{\&{str} primitive@>;
+@:str_}{\&{str} primitive@>
 mp_primitive (mp, "void", mp_void_op, 0);
-@:void_}{\&{void} primitive@>;
+@:void_}{\&{void} primitive@>
 mp_primitive (mp, "tension", mp_tension, 0);
-@:tension_}{\&{tension} primitive@>;
+@:tension_}{\&{tension} primitive@>
 mp_primitive (mp, "to", mp_to_token, 0);
-@:to_}{\&{to} primitive@>;
+@:to_}{\&{to} primitive@>
 mp_primitive (mp, "until", mp_until_token, 0);
-@:until_}{\&{until} primitive@>;
+@:until_}{\&{until} primitive@>
 mp_primitive (mp, "within", mp_within_token, 0);
-@:within_}{\&{within} primitive@>;
+@:within_}{\&{within} primitive@>
 mp_primitive (mp, "write", mp_write_command, 0);
 @:write_}{\&{write} primitive@>
 
@@ -5331,19 +5343,22 @@ typedef struct mp_node_data *mp_token_node;
 
 @ @c
 #if DEBUG
-#define value_sym(A)    do_get_value_sym(mp,(mp_token_node)(A))
-/* |#define value_number(A) do_get_value_number(mp,(mp_token_node)(A))| */
-#define value_number(A) ((mp_token_node)(A))->data.n
-#define value_node(A)   do_get_value_node(mp,(mp_token_node)(A))
-#define value_str(A)    do_get_value_str(mp,(mp_token_node)(A))
-#define value_knot(A)   do_get_value_knot(mp,(mp_token_node)(A))
+#define value_sym(A)    @[do_get_value_sym(mp,(mp_token_node)(A))@]
+@[@]/*|
+#define value_number(A) @[do_get_value_number(mp,(mp_token_node)(A))@]
+| */
+#define value_number(A) @[((mp_token_node)(A))->data.n@]
+#define value_node(A)   @[do_get_value_node(mp,(mp_token_node)(A))@]
+#define value_str(A)    @[do_get_value_str(mp,(mp_token_node)(A))@]
+#define value_knot(A)   @[do_get_value_knot(mp,(mp_token_node)(A))@]
 #else
-#define value_sym(A)    ((mp_token_node)(A))->data.sym
-#define value_number(A) ((mp_token_node)(A))->data.n
-#define value_node(A)   ((mp_token_node)(A))->data.node
-#define value_str(A)    ((mp_token_node)(A))->data.str
-#define value_knot(A)   ((mp_token_node)(A))->data.p
+#define value_sym(A)    @[((mp_token_node)(A))->data.sym@]
+#define value_number(A) @[((mp_token_node)(A))->data.n@]
+#define value_node(A)   @[((mp_token_node)(A))->data.node@]
+#define value_str(A)    @[((mp_token_node)(A))->data.str@]
+#define value_knot(A)   @[((mp_token_node)(A))->data.p@]
 #endif
+@/@t\2\2\4\4@>
 static void do_set_value_sym(MP mp, mp_token_node A, mp_sym B) {
    FUNCTION_TRACE3 ("set_value_sym(%p,%p)\n", (A),(B));
    A->data.sym=(B);
@@ -5426,8 +5441,7 @@ static void do_set_value_node   (MP mp, mp_token_node A, mp_node B);
 static void do_set_value_str    (MP mp, mp_token_node A, mp_string B);
 static void do_set_value_knot   (MP mp, mp_token_node A, mp_knot B);
 
-@
-@c
+@ @c
 static mp_node mp_get_token_node (MP mp) {
   mp_node p;
   if (mp->token_nodes) {
@@ -5516,7 +5530,7 @@ static void mp_flush_token_list (MP mp, mp_node p) {
         break;
       default:
         mp_confusion (mp, "token");
-@:this can't happen token}{\quad token@>;
+@:this can't happen token}{\quad token@>
       }
       mp_free_token_node (mp, q);
     }
@@ -5730,7 +5744,7 @@ static void mp_show_macro (MP mp, mp_node p, mp_node q, integer l) {
     else
       return;
   }                             /* control printing of `\.{ETC.}' */
-@.ETC@>;
+@.ETC@>
   mp->tally = 0;
   switch (mp_sym_info (p)) {
   case mp_general_macro:
@@ -5822,7 +5836,7 @@ structure is not worth the minimal extra code clarification.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_value_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_value_data data;
   mp_number subscript_;
   mp_sym hashloc_;
@@ -6016,10 +6030,10 @@ information in their collective subscript attributes.
 
 @c
 #if DEBUG
-#define hashloc(A)       do_get_hashloc(mp,(mp_value_node)(A))
-#define set_hashloc(A,B) do_set_hashloc (mp,(mp_value_node)A, B)
-#define parent(A)        do_get_parent(mp, A)
-#define set_parent(A,B)  do_set_parent (mp,(mp_value_node)A, B)
+#define hashloc(A)       @[do_get_hashloc(mp,(mp_value_node)(A))@]
+#define set_hashloc(A,B) @[do_set_hashloc (mp,(mp_value_node)A, B)@]
+#define parent(A)        @[do_get_parent(mp, A)@]
+#define set_parent(A,B)  @[do_set_parent (mp,(mp_value_node)A, B)@]
 static mp_sym do_get_hashloc (MP mp, mp_value_node A) {
   assert((A)->type == mp_attr_node_type || (A)->name_type == mp_attr);
   return (A)->hashloc_;
@@ -6039,17 +6053,16 @@ static void do_set_parent (MP mp, mp_value_node A, mp_node d) {
    A->parent_ = d;
 }
 #else
-#define hashloc(A)       ((mp_value_node)(A))->hashloc_
-#define set_hashloc(A,B) ((mp_value_node)(A))->hashloc_ = B
-#define parent(A)        ((mp_value_node)(A))->parent_
-#define set_parent(A,B)  ((mp_value_node)(A))->parent_ = B
+#define hashloc(A)       @[((mp_value_node)(A))->hashloc_@]
+#define set_hashloc(A,B) @[((mp_value_node)(A))->hashloc_ = B@]
+#define parent(A)        @[((mp_value_node)(A))->parent_@]
+#define set_parent(A,B)  @[((mp_value_node)(A))->parent_ = B@]
 #endif
 
-@
-@d mp_free_attr_node(a,b) do {
+@ @d mp_free_attr_node(a,b) do {
    assert((b)->type == mp_attr_node_type || (b)->name_type == mp_attr);
    mp_free_value_node(a,b);
-} while (0)
+} while (0)@;
 
 @c
 static mp_value_node mp_get_attr_node (MP mp) {
@@ -6074,8 +6087,7 @@ set_parent ((mp_value_node) mp->end_attr, NULL);
 @ @<Free table...@>=
 mp_free_attr_node (mp, mp->end_attr);
 
-@
-@d collective_subscript (void *)0 /* code for the attribute `\.{[]}' */
+@ @d collective_subscript (void *)0 /* code for the attribute `\.{[]}' */
 @d subscript(A) ((mp_value_node)(A))->subscript_
 @d set_subscript(A,B) do_set_subscript (mp, (mp_value_node)(A), B)
 
@@ -6086,8 +6098,7 @@ static void do_set_subscript (MP mp, mp_value_node A, mp_number B) {
   number_clone(A->subscript_,B); /* subscript of this variable */
 }
 
-@
-@c
+@ @c
 static mp_value_node mp_get_subscr_node (MP mp) {
   mp_value_node p = (mp_value_node) mp_get_value_node (mp);
   mp_type (p) = mp_subscr_node_type;
@@ -6106,14 +6117,13 @@ to this four-word node.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_pair_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_node x_part_;
   mp_node y_part_;
 } mp_pair_node_data;
 typedef struct mp_pair_node_data *mp_pair_node;
 
-@
-@d pair_node_size sizeof(struct mp_pair_node_data) /* the number of words in a subscript node */
+@ @d pair_node_size sizeof(struct mp_pair_node_data) /* the number of words in a subscript node */
 
 @c
 static mp_node mp_get_pair_node (MP mp) {
@@ -6170,8 +6180,7 @@ static void mp_init_pair_node (MP mp, mp_node p) {
 }
 
 
-@
-Variables of type \&{transform} are similar, but in this case their
+@ Variables of type \&{transform} are similar, but in this case their
 |value| points to a 12-word node containing six values, identified by
 |x_part_sector|, |y_part_sector|, |mp_xx_part_sector|, |mp_xy_part_sector|,
 |mp_yx_part_sector|, and |mp_yy_part_sector|.
@@ -6185,7 +6194,7 @@ Variables of type \&{transform} are similar, but in this case their
 
 @<MPlib internal header stuff@>=
 typedef struct mp_transform_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_node tx_part_;
   mp_node ty_part_;
   mp_node xx_part_;
@@ -6195,8 +6204,7 @@ typedef struct mp_transform_node_data {
 } mp_transform_node_data;
 typedef struct mp_transform_node_data *mp_transform_node;
 
-@
-@d transform_node_size sizeof(struct mp_transform_node_data) /* the number of words in a subscript node */
+@ @d transform_node_size sizeof(struct mp_transform_node_data) /* the number of words in a subscript node */
 
 @c
 static mp_node mp_get_transform_node (MP mp) {
@@ -6239,8 +6247,7 @@ static void mp_init_transform_node (MP mp, mp_node p) {
 }
 
 
-@
-Variables of type \&{color} have 3~values in 6~words identified by |mp_red_part_sector|,
+@ Variables of type \&{color} have 3~values in 6~words identified by |mp_red_part_sector|,
 |mp_green_part_sector|, and |mp_blue_part_sector|.
 
 @d red_part(A) ((mp_color_node)(A))->red_part_ /* where the \&{redpart} is found in a color node */
@@ -6251,15 +6258,14 @@ Variables of type \&{color} have 3~values in 6~words identified by |mp_red_part_
 
 @<MPlib internal header stuff@>=
 typedef struct mp_color_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_node red_part_;
   mp_node green_part_;
   mp_node blue_part_;
 } mp_color_node_data;
 typedef struct mp_color_node_data *mp_color_node;
 
-@
-@d color_node_size sizeof(struct mp_color_node_data) /* the number of words in a subscript node */
+@ @d color_node_size sizeof(struct mp_color_node_data) /* the number of words in a subscript node */
 
 @c
 static mp_node mp_get_color_node (MP mp) {
@@ -6270,8 +6276,7 @@ static mp_node mp_get_color_node (MP mp) {
 }
 
 
-@
-@c
+@ @c
 static void mp_init_color_node (MP mp, mp_node p) {
   mp_node q;    /* the new node */
   mp_type (p) = mp_color_type;
@@ -6301,7 +6306,7 @@ static void mp_init_color_node (MP mp, mp_node p) {
 
 @<MPlib internal header stuff@>=
 typedef struct mp_cmykcolor_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_node cyan_part_;
   mp_node magenta_part_;
   mp_node yellow_part_;
@@ -6309,8 +6314,7 @@ typedef struct mp_cmykcolor_node_data {
 } mp_cmykcolor_node_data;
 typedef struct mp_cmykcolor_node_data *mp_cmykcolor_node;
 
-@
-@d cmykcolor_node_size sizeof(struct mp_cmykcolor_node_data) /* the number of words in a subscript node */
+@ @d cmykcolor_node_size sizeof(struct mp_cmykcolor_node_data) /* the number of words in a subscript node */
 
 @c
 static mp_node mp_get_cmykcolor_node (MP mp) {
@@ -6321,8 +6325,7 @@ static mp_node mp_get_cmykcolor_node (MP mp) {
 }
 
 
-@
-@c
+@ @c
 static void mp_init_cmykcolor_node (MP mp, mp_node p) {
   mp_node q;    /* the new node */
   mp_type (p) = mp_cmykcolor_type;
@@ -6361,7 +6364,7 @@ static mp_node mp_id_transform (MP mp) {
   mp_node p, q; /* list manipulation registers */
   p = mp_get_value_node (mp);
   mp_name_type (p) = mp_capsule;
-  set_value_number (p, zero_t);             /* todo: this was |null| */
+  set_value_number (p, zero_t);             /* TODO: this was |NULL| */
   mp_init_transform_node (mp, p);
   q = value_node (p);
   mp_type (tx_part (q)) = mp_known;
@@ -6423,8 +6426,8 @@ void mp_print_variable_name (MP mp, mp_node p) {
     case mp_black_part_sector:  mp_print (mp, "blackpart ");  break;
     case mp_grey_part_sector:   mp_print (mp, "greypart ");   break;
     case mp_capsule:            mp_printf (mp, "%%CAPSULE%p",p); return; break;
-    /* this is to please the compiler: the remaining cases are operation codes */
-    default: break;
+    default: /* this is to please the compiler: the remaining cases are operation codes */
+      break;
     }
     p = mp_link (p);
   }
@@ -6627,7 +6630,7 @@ static mp_node mp_new_structure (MP mp, mp_node p) {
   return r;
 }
 
-@ The |find_variable| routine is given a pointer~|t| to a nonempty token
+@ The |mp_find_variable| routine is given a pointer~|t| to a nonempty token
 list of suffixes; it returns a pointer to the corresponding non-symbolic
 value. For example, if |t| points to token \.x followed by a numeric
 token containing the value~7, |find_variable| finds where the value of
@@ -6646,7 +6649,7 @@ static mp_node mp_find_variable (MP mp, mp_node t) {
   mp_node p, q, r, s;   /* nodes in the ``value'' line */
   mp_sym p_sym;
   mp_node pp, qq, rr, ss;       /* nodes in the ``collective'' line */
-@^inner loop@>;
+@^inner loop@>
   p_sym = mp_sym_sym (t);
   t = mp_link (t);
   if ((eq_type (p_sym) % mp_outer_tag) != mp_tag_token)
@@ -7182,8 +7185,7 @@ typedef struct mp_knot_data {
 } mp_knot_data;
 
 
-@
-@d mp_gr_next_knot(A)   (A)->next /* the next knot in this list */
+@ @d mp_gr_next_knot(A)   (A)->next /* the next knot in this list */
 
 @<Exported types...@>=
 typedef struct mp_gr_knot_data *mp_gr_knot;
@@ -7245,7 +7247,7 @@ The rules for |mp_left_type| are similar, but they refer to the curve entering
 the knot, and to \\{left} fields instead of \\{right} fields.
 
 Non-|explicit| control points will be chosen based on ``tension'' parameters
-in the |left_tension| and |right_tension| fields. The
+in the |left_tension|/|right_tension| fields. The
 `\&{atleast}' option is represented by negative tension values.
 @:at_least_}{\&{atleast} primitive@>
 
@@ -7276,6 +7278,8 @@ path syntax:
 |mp_left_type| of the following node is |explicit|.
 (iii)~|endpoint| types occur only at the ends, as mentioned above.
 
+@s explicit x @q Undefine C++ keyword @>
+
 @d left_curl left_x /* curl information when entering this knot */
 @d left_given left_x /* given direction when entering this knot */
 @d left_tension left_y /* tension information when entering this knot */
@@ -7321,9 +7325,8 @@ void mp_pr_path (MP mp, mp_knot h) {
     @<Print information for adjacent knots |p| and |q|@>;
   DONE1:
     p = q;
-    if (p && ((p != h) || (mp_left_type (h) != mp_endpoint))) {
-      @<Print two dots, followed by |given| or |curl| if present@>;
-    }
+    if (p && ((p != h) || (mp_left_type (h) != mp_endpoint)))
+      @<Print two dots, followed by |given| or |curl| if present@>@;
   } while (p != h);
   if (mp_left_type (h) != mp_endpoint)
     mp_print (mp, "cycle");
@@ -7336,7 +7339,7 @@ switch (mp_right_type (p)) {
 case mp_endpoint:
   if (mp_left_type (p) == mp_open)
     mp_print (mp, "{open?}");   /* can't happen */
-@.open?@>;
+@.open?@>
   if ((mp_left_type (q) != mp_endpoint) || (q != h))
     q = NULL;                   /* force an error */
   goto DONE1;
@@ -7353,15 +7356,14 @@ case mp_given:
   break;
 default:
   mp_print (mp, "???");         /* can't happen */
-@.???@>;
+@.???@>
   break;
 }
 if (mp_left_type (q) <= mp_explicit) {
   mp_print (mp, "..control?");  /* can't happen */
 @.control?@>
-} else if ((!number_equal(p->right_tension, unity_t)) || (!number_equal(q->left_tension, unity_t))) {
-  @<Print tension between |p| and |q|@>;
-}
+} else if ((!number_equal(p->right_tension, unity_t)) || (!number_equal(q->left_tension, unity_t)))
+  @<Print tension between |p| and |q|@>@;
 
 @ Since |n_sin_cos| produces |fraction| results, which we will print as if they
 were |scaled|, the magnitude of a |given| direction vector will be~4096.
@@ -7439,7 +7441,7 @@ if ((mp_left_type (p) != mp_explicit) && (mp_left_type (p) != mp_open)) {
 {
   if (mp_left_type (p) == mp_open)
     mp_print (mp, "??");        /* can't happen */
-@.??@>;
+@.??@>
   if (mp_right_type (p) == mp_curl) {
     mp_print (mp, "{curl ");
     print_number (p->right_curl);
@@ -7469,7 +7471,7 @@ static void mp_print_path (MP mp, mp_knot h, const char *s, boolean nuline);
 void mp_print_path (MP mp, mp_knot h, const char *s, boolean nuline) {
   mp_print_diagnostic (mp, "Path", s, nuline);
   mp_print_ln (mp);
-@.Path at line...@>;
+@.Path at line...@>
   mp_pr_path (mp, h);
   mp_end_diagnostic (mp, true);
 }
@@ -7789,7 +7791,7 @@ void mp_make_choices (MP mp, mp_knot knots) {
   mp_knot p, q; /* consecutive breakpoints being processed */
   @<Other local variables for |make_choices|@>;
   FUNCTION_TRACE1 ("make_choices()\n");
-  check_arith();                  /* make sure that |arith_error=false| */
+  check_arith();                  /* make sure that |arith_error==false| */
   if (number_positive(internal_value (mp_tracing_choices)))
     mp_print_path (mp, knots, ", before choices", true);
   @<If consecutive knots are equal, join them explicitly@>;
@@ -7802,9 +7804,8 @@ void mp_make_choices (MP mp, mp_knot knots) {
   } while (p != h);
   if (number_positive(internal_value (mp_tracing_choices)))
     mp_print_path (mp, knots, ", after choices", true);
-  if (mp->arith_error) {
-    @<Report an unexpected problem during the choice-making@>;
-  }
+  if (mp->arith_error)
+    @<Report an unexpected problem during the choice-making@>@;
 }
 
 @ @<Internal ...@>=
@@ -7817,7 +7818,7 @@ void mp_make_choices (MP mp, mp_knot knots);
          "So it will probably look funny. Proceed, for a laugh.",
           NULL };
   mp_back_error (mp, "Some number got too big", hlp, true);
-@.Some number got too big@>;
+@.Some number got too big@>
   mp_get_x_next (mp);
   mp->arith_error = false;
 }
@@ -7850,7 +7851,7 @@ do {
     number_clone (q->left_y, p->y_coord);
   }
   p = q;
-} while (p != knots)
+} while (p != knots)@;
 
 @ If there are no breakpoints, it is necessary to compute the direction
 angles around an entire cycle. In this case the |mp_left_type| of the first
@@ -7881,9 +7882,8 @@ if (mp_right_type (p) >= mp_given) {
     q = mp_next_knot (q);
   }
   @<Fill in the control information between consecutive breakpoints |p| and |q|@>;
-} else if (mp_right_type (p) == mp_endpoint) {
-  @<Give reasonable values for the unused control points between |p| and~|q|@>;
-}
+} else if (mp_right_type (p) == mp_endpoint)
+  @<Give reasonable values for the unused control points between |p| and~|q|@>@;
 p = q
 
 @ This step makes it possible to transform an explicitly computed path without
@@ -8247,11 +8247,11 @@ void mp_solve_choices (MP mp, mp_knot p, mp_knot q, halfword n) {
   r = 0;
   while (1) {
     t = mp_next_knot (s);
-    if (k == 0) {
+    if (k == 0)
       @<Get the linear equations started; or |return|
         with the control points in place, if linear equations
-        needn't be solved@>
-    } else {
+        needn't be solved@>@;
+    else {
       switch (mp_left_type (s)) {
       case mp_end_cycle:
       case mp_open:
@@ -8283,29 +8283,28 @@ FOUND:
 defined. The first linear equation, if any, will have $A_0=B_0=0$.
 
 @<Get the linear equations started...@>=
-switch (mp_right_type (s)) {
-case mp_given:
-  if (mp_left_type (t) == mp_given) {
-    @<Reduce to simple case of two givens  and |return|@>
-  } else {
-    @<Set up the equation for a given value of $\theta_0$@>;
-  }
-  break;
-case mp_curl:
-  if (mp_left_type (t) == mp_curl) {
-    @<Reduce to simple case of straight line and |return|@>
-  } else {
-    @<Set up the equation for a curl at $\theta_0$@>;
-  }
-  break;
-case mp_open:
-  set_number_to_zero(mp->uu[0]);
-  set_number_to_zero(mp->vv[0]);
-  number_clone(mp->ww[0], fraction_one_t);
-  /* this begins a cycle */
-  break;
-}                               /* there are no other cases */
-
+{
+  switch (mp_right_type (s)) {
+  case mp_given:
+    if (mp_left_type (t) == mp_given)
+      @<Reduce to simple case of two givens  and |return|@>@;
+    else
+      @<Set up the equation for a given value of $\theta_0$@>@;
+    break;
+  case mp_curl:
+    if (mp_left_type (t) == mp_curl)
+      @<Reduce to simple case of straight line and |return|@>@;
+    else
+      @<Set up the equation for a curl at $\theta_0$@>@;
+    break;
+  case mp_open:
+    set_number_to_zero(mp->uu[0]);
+    set_number_to_zero(mp->vv[0]);
+    number_clone(mp->ww[0], fraction_one_t);
+    /* this begins a cycle */
+    break;
+  }                               /* there are no other cases */
+}
 
 @ The general equation that specifies equality of mock curvature at $z_k$ is
 $$A_k\theta_{k-1}+(B_k+C_k)\theta_k+D_k\theta\k=-B_k\psi_k-D_k\psi\k,$$
@@ -8323,7 +8322,7 @@ suitable precision.
 The calculations will be performed in several registers that
 provide temporary storage for intermediate quantities.
 
-@ @<Set up equation to match mock curvatures...@>=
+@<Set up equation to match mock curvatures...@>=
 {
   mp_number aa, bb, cc, acc;   /* temporary registers */
   mp_number dd, ee;  /* likewise, but |scaled| */
@@ -8339,9 +8338,8 @@ provide temporary storage for intermediate quantities.
   @<Calculate the ratio $\\{ff}=C_k/(C_k+B_k-u_{k-1}A_k)$@>;
   take_fraction (mp->uu[k], ff, bb);
   @<Calculate the values of $v_k$ and $w_k$@>;
-  if (mp_left_type (s) == mp_end_cycle) {
-    @<Adjust $\theta_n$ to equal $\theta_0$ and |goto found|@>;
-  }
+  if (mp_left_type (s) == mp_end_cycle)
+    @<Adjust $\theta_n$ to equal $\theta_0$ and |goto found|@>@;
   free_number(aa);
   free_number(bb);
   free_number(cc);
@@ -8524,7 +8522,7 @@ so we can solve for $\theta_n=\theta_0$.
   new_number (arg2);
   new_number (r1);
   set_number_to_zero (aa);
-  number_clone (bb, fraction_one_t);            /* we have |k=n| */
+  number_clone (bb, fraction_one_t);            /* we have |k==n| */
   do {
     decr (k);
     if (k == 0)
@@ -8832,10 +8830,9 @@ void mp_set_controls (MP mp, mp_knot p, mp_knot q, integer k) {
   new_fraction (ss);
   velocity (rr, mp->st, mp->ct, mp->sf, mp->cf, rt);
   velocity (ss, mp->sf, mp->cf, mp->st, mp->ct, lt);
-  if (number_negative(p->right_tension) || number_negative(q->left_tension)) {
+  if (number_negative(p->right_tension) || number_negative(q->left_tension))
     @<Decrease the velocities,
-      if necessary, to stay inside the bounding triangle@>;
-  }
+      if necessary, to stay inside the bounding triangle@>@;
   take_fraction (r1, mp->delta_x [k], mp->ct);
   take_fraction (r2, mp->delta_y [k], mp->st);
   number_substract (r1, r2);
@@ -9042,7 +9039,6 @@ static int out_of_range(MP mp, double a)
     return 0;
 }
 
-static int mp_link_knotpair (MP mp, mp_knot p, mp_knot q);
 static int mp_link_knotpair (MP mp, mp_knot p, mp_knot q)
 {
     if (p==NULL ||q==NULL) return 0;
@@ -9236,9 +9232,7 @@ int mp_set_knotpair_directions (MP mp, mp_knot p, mp_knot q, double x1, double y
     return 0;
 }
 
-@
-@c
-static int path_needs_fixing (mp_knot source);
+@ @c
 static int path_needs_fixing (mp_knot source) {
     mp_knot sourcehead = source;
     do {
@@ -9478,9 +9472,8 @@ static void mp_bound_cubic (MP mp, mp_knot p, mp_knot q, quarterword c) {
       number_negate (del3);
     }
     crossing_point (t, del1, del2, del3);
-    if (number_less(t, fraction_one_t)) {
-      @<Test the extremes of the cubic against the bounding box@>;
-    }
+    if (number_less(t, fraction_one_t))
+      @<Test the extremes of the cubic against the bounding box@>@;
   }
   free_number (del3);
   free_number (del2);
@@ -9577,9 +9570,8 @@ must cut it to zero to avoid confusion.
     free_number (arg2);
     free_number (arg3);
   }
-  if (number_less(tt, fraction_one_t)) {
-    @<Test the second extreme against the bounding box@>;
-  }
+  if (number_less(tt, fraction_one_t))
+    @<Test the second extreme against the bounding box@>@;
 }
 
 
@@ -9725,13 +9717,11 @@ static void mp_arc_test (MP mp, mp_number *ret, mp_number dx0, mp_number dy0, mp
  if (simple && number_lessequal(simply, tol)) {
     if (number_less(arc, a_goal)){
       number_clone(*ret, arc);
-    } else {
+    } else
       @<Estimate when the arc length reaches |a_goal| and set |arc_test| to
-         that time minus |two|@>;
-    }
-  } else {
-    @<Use one or two recursive calls to compute the |arc_test| function@>;
-  }
+         that time minus |two|@>@;
+  } else
+    @<Use one or two recursive calls to compute the |arc_test| function@>@;
 DONE:
   free_number (arc);
   free_number (arc1);
@@ -9777,11 +9767,11 @@ calls, but $1.5$ is an adequate approximation.  It is best to avoid using
   mp_arc_test (mp, &a, dx0, dy0, dx01, dy01, dx02, dy02,
                               v0, v002, half_v02, a_new, tol);
   if (number_negative(a)) {
-    set_number_to_unity(*ret);
-    number_double(*ret); /* two */
-    number_substract(*ret, a); /* two - a */
+    set_number_to_unity(*ret); /* |1| */
+    number_double(*ret); /* |2| */
+    number_substract(*ret, a); /* |2 - a| */
     number_halfp(*ret);
-    number_negate(*ret); /* -halfp(two - a) */
+    number_negate(*ret); /* |-halfp(2 - a)| */
   } else {
     @<Update |a_new| to reduce |a_new+a_aux| by |a|@>;
     new_number (b);
@@ -9797,12 +9787,12 @@ calls, but $1.5$ is an adequate approximation.  It is best to avoid using
       number_clone(*ret, tmp);
       set_number_to_unity(tmp);
       number_halfp(tmp);
-      number_substract(*ret, tmp); /* (-(halfp(-b)) - 1/2) */
+      number_substract(*ret, tmp); /* |-(halfp(-b)) - 1/2| */
       free_number (tmp);
     } else {
       set_number_from_substraction(*ret, b, a);
       number_half(*ret);
-      set_number_from_addition(*ret, a, *ret); /* (a + half(b - a)) */
+      set_number_from_addition(*ret, a, *ret); /* |a + half(b - a)| */
     }
     free_number (b);
   }
@@ -9898,8 +9888,7 @@ number_half(dy02);
   number_half (arc);
   set_number_from_addition(arc, v022, arc);
 
-  /* reuse |tmp| for the next |if| test: */
-  set_number_to_inf(tmp);
+  set_number_to_inf(tmp); /* reuse |tmp| for the next |if| test */
   number_substract(tmp,arc1);
   if (number_less(arc, tmp)) {
     free_number (tmp);
@@ -9912,7 +9901,7 @@ number_half(dy02);
     } else {
       set_number_to_unity(*ret);
       number_double(*ret);
-      number_negate(*ret); /* -two */
+      number_negate(*ret); /* |-2| */
     }
     goto DONE;
   }
@@ -10002,7 +9991,7 @@ $\tau$ given $a$, $b$, $c$, and $x$.
   number_clone(tmp, v02);
   number_add_scaled(tmp, 2);
   number_half(tmp);
-  number_half(tmp); /* (v02+2) / 4 */
+  number_half(tmp); /* |(v02+2) / 4| */
   if (number_lessequal(a_goal, arc1)) {
     number_clone(tmp2, v0);
     number_halfp(tmp2);
@@ -10060,7 +10049,7 @@ void mp_solve_rising_cubic (MP mp, mp_number *ret, mp_number a_orig, mp_number b
   mp_number neg_x; /* temporary for an |if| */
   if (number_negative(a_orig) || number_negative(c_orig))
     mp_confusion (mp, "rising?");
-@:this can't happen rising?}{\quad rising?@>;
+@:this can't happen rising?}{\quad rising?@>
   new_number (t);
   new_number (abc);
   new_number (a);
@@ -10290,11 +10279,10 @@ static void mp_get_arc_time (MP mp, mp_number *ret, mp_knot h, mp_number arc0_or
     set_number_from_substraction(arg6, q->y_coord, q->left_y);
     mp_do_arc_test (mp, &t, arg1, arg2, arg3, arg4, arg5, arg6, arc);
     @<Update |arc| and |t_tot| after |do_arc_test| has just returned |t|@>;
-    if (q == h) {
+    if (q == h)
       @<Update |t_tot| and |arc| to avoid going around the cyclic
-        path too many times but set |arith_error:=true| and |goto done| on
-        overflow@>;
-    }
+        path too many times but set |arith_error=true| and |goto done| on
+        overflow@>@;
     p = q;
   }
   check_arith();
@@ -10352,21 +10340,21 @@ if (number_positive(arc)) {
   new_number (d1);
   new_number (v1);
 
-  set_number_from_substraction (d1, arc0, arc); /* d1 = arc0 - arc */
+  set_number_from_substraction (d1, arc0, arc); /* |d1 = arc0 - arc| */
   if (number_greater (d1,arc)) {
-    set_number_to_zero(n1); /* n1 = 0 */
+    set_number_to_zero(n1); /* |n1 = 0| */
   } else {
-    set_number_from_div (n1, arc, d1); /* n1 = (arc / d1) */
+    set_number_from_div (n1, arc, d1); /* |n1 = (arc / d1)| */
     floor_scaled(n1);
   }  
   number_clone (n, n1);
-  set_number_from_mul (n1, n1, d1); /* n1 = (n1 * d1) */
-  number_substract (arc, n1); /* arc = arc - n1 */
+  set_number_from_mul (n1, n1, d1); /* |n1 = (n1 * d1)| */
+  number_substract (arc, n1); /* |arc = arc - n1| */
 
-  number_clone (d1, inf_t);         /* reuse d1 */
-  number_clone (v1, n);             /* v1 = n */
+  number_clone (d1, inf_t);         /* reuse |d1| */
+  number_clone (v1, n);             /* |v1 = n| */
     
-  set_number_from_int(v1, number_to_int(v1)+1); /* v1 = n1+1 */
+  set_number_from_int(v1, number_to_int(v1)+1); /* |v1 = n1+1| */
   set_number_from_div (d1, d1, v1); /* |d1 = EL_GORDO / v1| */
   if (number_greater (t_tot, d1)) {
     mp->arith_error = true;
@@ -10480,9 +10468,9 @@ static void mp_pr_pen (MP mp, mp_knot h);
 @ @c
 void mp_pr_pen (MP mp, mp_knot h) {
   mp_knot p, q; /* for list traversal */
-  if (pen_is_elliptical (h)) {
-    @<Print the elliptical pen |h|@>;
-  } else {
+  if (pen_is_elliptical (h))
+    @<Print the elliptical pen |h|@>@;
+  else {
     p = h;
     do {
       mp_print_two (mp, p->x_coord, p->y_coord);
@@ -10539,7 +10527,7 @@ static void mp_print_pen (MP mp, mp_knot h, const char *s, boolean nuline);
 void mp_print_pen (MP mp, mp_knot h, const char *s, boolean nuline) {
   mp_print_diagnostic (mp, "Pen", s, nuline);
   mp_print_ln (mp);
-@.Pen at line...@>;
+@.Pen at line...@>
   mp_pr_pen (mp, h);
   mp_end_diagnostic (mp, true);
 }
@@ -10563,18 +10551,18 @@ static void mp_make_path (MP mp, mp_knot h) {
     do {
       mp_left_type (p) = mp_explicit;
       mp_right_type (p) = mp_explicit;
-      @<copy the coordinates of knot |p| into its control points@>;
+      @<Copy the coordinates of knot |p| into its control points@>;
       p = mp_next_knot (p);
     } while (p != h);
   }
 }
 
 
-@ @<copy the coordinates of knot |p| into its control points@>=
+@ @<Copy the coordinates of knot |p| into its control points@>=
 number_clone (p->left_x, p->x_coord);
 number_clone (p->left_y, p->y_coord);
 number_clone (p->right_x, p->x_coord);
-number_clone (p->right_y, p->y_coord)
+number_clone (p->right_y, p->y_coord)@;
 
 
 @ We need an eight knot path to get a good approximation to an ellipse.
@@ -10664,7 +10652,7 @@ kk = (k + 6) % 8;
 }
 mp_left_type (p) = mp_explicit;
 mp_right_type (p) = mp_explicit;
-mp_originator (p) = mp_program_code
+mp_originator (p) = mp_program_code@;
 
 @ @<Glob...@>=
 mp_number half_cos[8];   /* ${1\over2}\cos(45k)$ */
@@ -10738,9 +10726,8 @@ mp_knot mp_convex_hull (MP mp, mp_knot h) {                               /* Mak
       @<Sort the path from |l| to |r| by increasing $x$@>;
       @<Sort the path from |r| to |l| by decreasing $x$@>;
     }
-    if (l != mp_next_knot (l)) {
-      @<Do a Gramm scan and remove vertices where there is no left turn@>;
-    }
+    if (l != mp_next_knot (l))
+      @<Do a Gramm scan and remove vertices where there is no left turn@>@;
     ret = l;
   }
   free_number (dx);
@@ -10800,10 +10787,10 @@ while (p != h) {
 }
 
 
-@ The |move_knot| procedure removes |p| from a doubly linked list and inserts
+@ The |mp_move_knot| procedure removes |p| from a doubly linked list and inserts
 it after |q|.
 
-@ @<Declarations@>=
+@<Declarations@>=
 static void mp_move_knot (MP mp, mp_knot p, mp_knot q);
 
 @ @c
@@ -10911,9 +10898,8 @@ where the |then| clause is not executed.
       set_number_from_substraction (arg1, q->y_coord, p->y_coord);
       set_number_from_substraction (arg2, q->x_coord, p->x_coord);
       ab_vs_cd (ab_vs_cd, dx, arg1, dy, arg2);
-      if (number_nonpositive(ab_vs_cd)) {
-        @<Remove knot |p| and back up |p| and |q| but don't go past |l|@>;
-      }
+      if (number_nonpositive(ab_vs_cd))
+        @<Remove knot |p| and back up |p| and |q| but don't go past |l|@>@;
     }
   }
   free_number (ab_vs_cd);
@@ -11106,9 +11092,9 @@ is stored in the global variables |minx|, |maxx|, |miny|, and |maxy|.
 @c
 static void mp_pen_bbox (MP mp, mp_knot h) {
   mp_knot p;    /* for scanning the knot list */
-  if (pen_is_elliptical (h)) {
-    @<Find the bounding box of an elliptical pen@>;
-  } else {
+  if (pen_is_elliptical (h))
+    @<Find the bounding box of an elliptical pen@>@;
+  else {
     number_clone (mp_minx, h->x_coord);
     number_clone (mp_maxx, mp_minx);
     number_clone (mp_miny, h->y_coord);
@@ -11155,13 +11141,16 @@ static void mp_pen_bbox (MP mp, mp_knot h) {
 
 This first set goes into the header
 
+@s mp_fraction mp_number
+@s mp_angle mp_number
+
 @<MPlib internal header stuff@>=
 #define mp_fraction mp_number
 #define mp_angle mp_number
-#define new_number(A) (((math_data *)(mp->math))->allocate)(mp, &(A), mp_scaled_type)
-#define new_fraction(A) (((math_data *)(mp->math))->allocate)(mp, &(A), mp_fraction_type)
-#define new_angle(A) (((math_data *)(mp->math))->allocate)(mp, &(A), mp_angle_type)
-#define free_number(A) (((math_data *)(mp->math))->free)(mp, &(A))
+#define new_number(A) @[(((math_data *)(mp->math))->allocate)(mp, &(A), mp_scaled_type)@]
+#define new_fraction(A) @[(((math_data *)(mp->math))->allocate)(mp, &(A), mp_fraction_type)@]
+#define new_angle(A) @[(((math_data *)(mp->math))->allocate)(mp, &(A), mp_angle_type)@]
+#define free_number(A) @[(((math_data *)(mp->math))->free)(mp, &(A))@]
 
 @
 @d set_precision()                     (((math_data *)(mp->math))->set_precision)(mp)
@@ -11183,7 +11172,7 @@ This first set goes into the header
 @d set_number_to_unity(A)	       (((math_data *)(mp->math))->clone)(&(A), unity_t)
 @d set_number_to_zero(A)	       (((math_data *)(mp->math))->clone)(&(A), zero_t)
 @d set_number_to_inf(A)		       (((math_data *)(mp->math))->clone)(&(A), inf_t)
-@d set_number_to_neg_inf(A)	       do { set_number_to_inf(A); number_negate (A); } while (0)
+@d set_number_to_neg_inf(A)	       do { set_number_to_inf(A); number_negate (A); } while (0)@;
 @#
 @d init_randoms(A)                     (((math_data *)(mp->math))->init_randoms)(mp,A)
 @d print_number(A)                     (((math_data *)(mp->math))->print)(mp,A)
@@ -11266,7 +11255,7 @@ let the second one overwrite it if necessary.
 
 @<MPlib header stuff@>=
 enum mp_graphical_object_code {
-  @<Graphical object codes@>
+  @<Graphical object codes@>@;
   mp_final_graphic
 };
 
@@ -11289,7 +11278,7 @@ give the relevant information.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_fill_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   halfword color_model_;
   mp_number red;
   mp_number green;
@@ -11305,7 +11294,7 @@ typedef struct mp_fill_node_data {
 typedef struct mp_fill_node_data *mp_fill_node;
 
 @ @<Graphical object codes@>=
-mp_fill_code = 1,
+mp_fill_code = 1,@[@]@;
 
 @ Make a fill node for cyclic path |p| and color black.
 
@@ -11370,7 +11359,7 @@ be transformed without touching the picture that |dash_p| points to.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_stroked_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   halfword color_model_;
   mp_number red;
   mp_number green;
@@ -11390,7 +11379,7 @@ typedef struct mp_stroked_node_data *mp_stroked_node;
 
 
 @ @<Graphical object codes@>=
-mp_stroked_code = 2,
+mp_stroked_code = 2,@[@]@;
 
 @  Make a stroked node for path |p| with |mp_pen_p(p)| temporarily |NULL|.
 
@@ -11434,7 +11423,7 @@ static mp_node mp_new_stroked_node (MP mp, mp_knot p) {
   return (mp_node) t;
 }
 
-@ @c
+@ @s mp_edge_header_node int @c
 static mp_edge_header_node mp_free_stroked_node (MP mp, mp_stroked_node p) {
   mp_edge_header_node e = NULL;
   mp_toss_knot_list (mp, mp_path_p (p));
@@ -11458,16 +11447,16 @@ static mp_edge_header_node mp_free_stroked_node (MP mp, mp_stroked_node p) {
 @ When a dashed line is computed in a transformed coordinate system, the dash
 lengths get scaled like the pen shape and we need to compensate for this.  Since
 there is no unique scale factor for an arbitrary transformation, we use the
-the square root of the determinant.  The properties of the determinant make it
+square root of the determinant.  The properties of the determinant make it
 easier to maintain the |dash_scale|.  The computation is fairly straight-forward
 except for the initialization of the scale factor |s|.  The factor of 64 is
 needed because |square_rt| scales its result by $2^8$ while we need $2^{14}$
 to counteract the effect of |take_fraction|.
 
-@ @c
+@c
 void mp_sqrt_det (MP mp, mp_number *ret, mp_number a_orig, mp_number b_orig, mp_number c_orig, mp_number d_orig) {
   mp_number a,b,c,d;
-  mp_number maxabs;        /* $max(|a|,|b|,|c|,|d|)$ */
+  mp_number maxabs;        /* |max(a,b,c,d)| */
   unsigned s;   /* amount by which the result of |square_rt| needs to be scaled */
   new_number(a);
   new_number(b);
@@ -11570,7 +11559,7 @@ black with its reference point at the origin.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_text_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   halfword color_model_;
   mp_number red;
   mp_number green;
@@ -11593,7 +11582,7 @@ typedef struct mp_text_node_data {
 typedef struct mp_text_node_data *mp_text_node;
 
 @ @<Graphical object codes@>=
-mp_text_code = 3,
+mp_text_code = 3,@[@]@;
 
 @  Make a text node for font |f| and text string |s|.
 
@@ -11671,12 +11660,12 @@ of objects to clip or bound followed by a closing node.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_start_clip_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_knot path_p_;
 } mp_start_clip_node_data;
 typedef struct mp_start_clip_node_data *mp_start_clip_node;
 typedef struct mp_start_bounds_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_knot path_p_;
 } mp_start_bounds_node_data;
 typedef struct mp_start_bounds_node_data *mp_start_bounds_node;
@@ -11694,11 +11683,10 @@ typedef struct mp_stop_bounds_node_data *mp_stop_bounds_node;
 mp_start_clip_code = 4,         /* |type| of a node that starts clipping */
   mp_start_bounds_code = 5,     /* |type| of a node that gives a \&{setbounds} path */
   mp_stop_clip_code = 6,        /* |type| of a node that stops clipping */
-  mp_stop_bounds_code = 7,      /* |type| of a node that stops \&{setbounds} */
+  mp_stop_bounds_code = 7,@[@]@;      /* |type| of a node that stops \&{setbounds} */
 
 
 @
-
 @d start_clip_size sizeof(struct mp_start_clip_node_data)
 @d stop_clip_size sizeof(struct mp_stop_clip_node_data)
 @d start_bounds_size sizeof(struct mp_start_bounds_node_data)
@@ -11780,7 +11768,7 @@ The |dash_info| is explained below.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_dash_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_number start_x; /* the starting $x$~coordinate in a dash node */
   mp_number stop_x; /* the ending $x$~coordinate in a dash node */
   mp_number dash_y; /* $y$ value for the dash list in an edge header */
@@ -11796,8 +11784,7 @@ mp->null_dash = mp_get_dash_node (mp);
 @ @<Free table entries@>=
 mp_free_node (mp, (mp_node)mp->null_dash, dash_node_size);
 
-@
-@d dash_node_size sizeof(struct mp_dash_node_data)
+@ @d dash_node_size sizeof(struct mp_dash_node_data)
 
 @c
 static mp_dash_node mp_get_dash_node (MP mp) {
@@ -11836,7 +11823,7 @@ field is needed to keep track of this.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_edge_header_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   mp_number start_x;
   mp_number stop_x;
   mp_number dash_y;
@@ -11893,7 +11880,7 @@ static mp_edge_header_node mp_get_edge_header_node (MP mp) {
   return p;
 }
 static void mp_init_edges (MP mp, mp_edge_header_node h) {
-  /* initialize an edge header to NULL values */
+  /* initialize an edge header to \.{NULL} values */
   set_dash_list (h, mp->null_dash);
   obj_tail (h) = edge_list (h);
   mp_link (edge_list (h)) = NULL;
@@ -11945,7 +11932,7 @@ void mp_toss_edges (MP mp, mp_edge_header_node h) {
 void mp_flush_dash_list (MP mp, mp_edge_header_node h) {
   mp_dash_node p, q; /* pointers that scan the list being recycled */
   q = dash_list (h);
-  while (q != mp->null_dash) { /* todo: NULL check should not be needed */
+  while (q != mp->null_dash) { /* TODO: |NULL| check should not be needed */
     p = q;
     q = (mp_dash_node)mp_link (q);
     mp_free_node (mp, (mp_node)p, dash_node_size);
@@ -12022,11 +12009,13 @@ while ((p != mp->null_dash)) {
   p = (mp_dash_node)mp_link (p);
 }
 mp_link (pp) = (mp_node)mp->null_dash;
-number_clone(hh->dash_y, h->dash_y )
+number_clone(hh->dash_y, h->dash_y )@;
 
 
 @ |h| is an edge structure
 
+@s mp_dash_object int
+
 @c
 static mp_dash_object *mp_export_dashes (MP mp, mp_stroked_node q, mp_number w) {
   mp_dash_object *d;
@@ -12100,7 +12089,7 @@ pp = (mp_dash_node)edge_list (hh);
 while ((p != (mp_dash_node)bblast (h))) {
   if (p == NULL)
     mp_confusion (mp, "bblast");
-@:this can't happen bblast}{\quad bblast@>;
+@:this can't happen bblast}{\quad bblast@>
   p = (mp_dash_node)mp_link (p);
   pp = (mp_dash_node)mp_link (pp);
 }
@@ -12123,9 +12112,9 @@ mp_edge_header_node mp_copy_objects (MP mp, mp_node p, mp_node q) {
   set_dash_list (hh, mp->null_dash);
   edge_ref_count (hh) = 0;
   pp = edge_list (hh);
-  while (p != q) {
-    @<Make |mp_link(pp)| point to a copy of object |p|, and update |p| and |pp|@>;
-  }
+  while (p != q)
+    @<Make |mp_link(pp)| point to a copy of object |p|,
+      and update |p| and |pp|@>@;
   obj_tail (hh) = pp;
   mp_link (pp) = NULL;
   return hh;
@@ -12305,7 +12294,7 @@ void mp_print_edges (MP mp, mp_node h, const char *s, boolean nuline) {
   mp_print_nl (mp, "End edges");
   if (p != obj_tail (h))
     mp_print (mp, "?");
-@.End edges?@>;
+@.End edges?@>
   mp_end_diagnostic (mp, true);
   free_number (scf);
 }
@@ -12341,7 +12330,7 @@ case 2:
   break;
 default:
   mp_print (mp, "?? joins");
-@.??@>;
+@.??@>
   break;
 }
 
@@ -12365,7 +12354,7 @@ default:
 @.??@>
 }
 mp_print (mp, " ends, ");
-@<Print join type for graphical object |p|@>
+@<Print join type for graphical object |p|@>@;
 
 
 @ Here is a routine that prints the color of a graphical object if it isn't
@@ -12383,7 +12372,7 @@ void mp_print_obj_color (MP mp, mp_node p) {
       mp_print_char (mp, xord ('('));
       print_number (p0->grey);
       mp_print_char (mp, xord (')'));
-    };
+    }
   } else if (mp_color_model (p) == mp_cmyk_model) {
     if (number_positive(p0->cyan) || number_positive(p0->magenta) ||
         number_positive(p0->yellow) || number_positive(p0->black)) {
@@ -12397,7 +12386,7 @@ void mp_print_obj_color (MP mp, mp_node p) {
       mp_print_char (mp, xord (','));
       print_number (p0->black);
       mp_print_char (mp, xord (')'));
-    };
+    }
   } else if (mp_color_model (p) == mp_rgb_model) {
     if (number_positive(p0->red) || number_positive(p0->green) ||
 	number_positive(p0->blue)) {
@@ -12409,7 +12398,7 @@ void mp_print_obj_color (MP mp, mp_node p) {
       mp_print_char (mp, xord (','));
       print_number (p0->blue);
       mp_print_char (mp, xord (')'));
-    };
+    }
   }
 }
 
@@ -12495,7 +12484,7 @@ static void mp_dash_offset (MP mp, mp_number *x, mp_dash_node h);
 void mp_dash_offset (MP mp, mp_number *x, mp_dash_node h) {
   if (dash_list (h) == mp->null_dash || number_negative(h->dash_y ))
     mp_confusion (mp, "dash0");
-@:this can't happen dash0}{\quad dash0@>;
+@:this can't happen dash0}{\quad dash0@>
   if (number_zero(h->dash_y)) {
     set_number_to_zero(*x);
   } else {
@@ -12581,7 +12570,7 @@ static mp_edge_header_node mp_make_dashes (MP mp, mp_edge_header_node h) { /* re
   p = mp_link (edge_list (h));
   while (p != NULL) {
     if (mp_type (p) != mp_stroked_node_type) {
-      @<Compain that the edge structure contains a node of the wrong type
+      @<Complain that the edge structure contains a node of the wrong type
         and |goto not_found|@>;
     }
     pp = mp_path_p ((mp_stroked_node) p);
@@ -12606,7 +12595,7 @@ NOT_FOUND:
 }
 
 
-@ @<Compain that the edge structure contains a node of the wrong type...@>=
+@ @<Complain that the edge structure contains a node of the wrong type...@>=
 {
   const char *hlp[] = {
          "When you say `dashed p', picture p should not contain any",
@@ -12752,10 +12741,10 @@ if (dd != (mp_dash_node)h) {
   if (number_greater(dd->stop_x, d->start_x)) {
     mp_x_retrace_error (mp);
     goto NOT_FOUND;
-  };
+  }
 }
 mp_link (d) = mp_link (dd);
-mp_link (dd) = (mp_node)d
+mp_link (dd) = (mp_node)d@;
 
 @ @<Set |dash_y(h)| and merge the first and last dashes if necessary@>=
 d = dash_list (h);
@@ -12785,7 +12774,7 @@ since it is not being used for the return value.
 @<Flush the dash list, recycle |h| and return |NULL|@>=
 mp_flush_dash_list (mp, h);
 delete_edge_ref (h);
-return NULL
+return NULL@;
 
 @ Having carefully saved the dashed stroked nodes in the
 corresponding dash nodes, we must be prepared to break up these dashes into
@@ -12805,14 +12794,15 @@ while (mp_link (d) != (mp_node)mp->null_dash) {
     number_clone(hsf, ((mp_stroked_node)ds)->dash_scale);
     if (hh == NULL)
       mp_confusion (mp, "dash1");
-@:this can't happen dash0}{\quad dash1@>;
-    /* clang: dereference null pointer 'hh' */ assert(hh);
+@:this can't happen dash0}{\quad dash1@>
+    assert(hh);
+    /* clang: dereference null pointer 'hh' */
     if (number_zero(((mp_dash_node)hh)->dash_y )) {
       d = (mp_dash_node)mp_link (d);
     } else {
       if (dash_list (hh) == NULL)
         mp_confusion (mp, "dash1");
-@:this can't happen dash0}{\quad dash1@>;
+@:this can't happen dash0}{\quad dash1@>
       @<Replace |mp_link(d)| by a dashed version as determined by edge header
           |hh| and scale factor |ds|@>;
     }
@@ -12911,16 +12901,14 @@ if (dd == mp->null_dash) {
     number_add (r1, xoff);
     if (number_greater(dln->start_x, r1))
       number_clone(d->start_x, dln->start_x);
-    else {
+    else
       number_clone(d->start_x, r1);
-    }
     take_scaled (r1, hsf, dd->stop_x);
     number_add (r1, xoff);
     if (number_less(dln->stop_x, r1))
       number_clone(d->stop_x, dln->stop_x );
-    else {
+    else
       number_clone(d->stop_x, r1);
-    }
   }
   free_number (r1);
 }
@@ -12979,9 +12967,8 @@ static void mp_box_ends (MP mp, mp_knot p, mp_knot pp, mp_edge_header_node h) {
       }
       if (mp_right_type (p) == mp_endpoint) {
         goto DONE;
-      } else {
-        @<Advance |p| to the end of the path and make |q| the previous knot@>;
-      }
+      } else
+        @<Advance |p| to the end of the path and make |q| the previous knot@>@;
     }
   }
 DONE:
@@ -13046,7 +13033,7 @@ set_number_from_substraction(dy, p->y_coord, q->y_coord);
   set_number_from_addition(d, r1, r2);
   if ((number_negative(d) && (i == 1)) || (number_positive(d) && (i == 2)))
     mp_confusion (mp, "box_ends");
-@:this can't happen box ends}{\quad\\{box\_ends}@>;
+@:this can't happen box ends}{\quad\\{box\_ends}@>
   take_fraction (r1, d, dx);
   set_number_from_addition(z, p->x_coord, mp->cur_x);
   number_add (z, r1);
@@ -13070,7 +13057,7 @@ set_number_from_substraction(dy, p->y_coord, q->y_coord);
 do {
   q = p;
   p = mp_next_knot (p);
-} while (mp_right_type (p) != mp_endpoint)
+} while (mp_right_type (p) != mp_endpoint);
 
 @ The major difficulty in finding the bounding box of an edge structure is the
 effect of clipping paths.  We treat them conservatively by only clipping to the
@@ -13108,9 +13095,9 @@ void mp_set_bbox (MP mp, mp_edge_header_node h, boolean top_level) {
         mp_confusion (mp, "bbox");
       else
         return;
-@:this can't happen bbox}{\quad bbox@>;
+@:this can't happen bbox}{\quad bbox@>
       break;
-      @<Other cases for updating the bounding box based on the type of object |p|@>;
+      @t\4@>@<Other cases for updating the bounding box based on the type of object |p|@>@;
     default:                   /* there are no other valid cases, but please the compiler */
       break;
     }
@@ -13165,7 +13152,7 @@ case mp_start_bounds_node_type:
 case mp_stop_bounds_node_type:
   if (number_nonpositive (internal_value (mp_true_corners)))
     mp_confusion (mp, "bbox2");
-@:this can't happen bbox2}{\quad bbox2@>;
+@:this can't happen bbox2}{\quad bbox2@>
   break;
 
 @ @<Scan to the matching |mp_stop_bounds_node| node and update |p| and...@>=
@@ -13173,7 +13160,7 @@ lev = 1;
 while (lev != 0) {
   if (mp_link (p) == NULL)
     mp_confusion (mp, "bbox2");
-@:this can't happen bbox2}{\quad bbox2@>;
+@:this can't happen bbox2}{\quad bbox2@>
   /* clang: dereference null pointer */ assert(mp_link(p));
   p = mp_link (p);
   if (mp_type (p) == mp_start_bounds_node_type)
@@ -13181,7 +13168,7 @@ while (lev != 0) {
   else if (mp_type (p) == mp_stop_bounds_node_type)
     decr (lev);
 }
-bblast (h) = p
+bblast (h) = p@;
 
 @ It saves a lot of grief here to be slightly conservative and not account for
 omitted parts of dashed lines.  We also don't worry about the material omitted
@@ -13212,7 +13199,7 @@ mp_path_bbox (mp, mp_path_p ((mp_stroked_node) p));
     free_number (y1a);
 }
 mp_adjust_bbox (mp, h);
-if ((mp_left_type (mp_path_p ((mp_stroked_node) p)) == mp_endpoint)
+if ((mp_left_type (mp_path_p ((mp_stroked_node) p)) == mp_endpoint) @|
     && (((mp_stroked_node) p)->lcap == 2))
   mp_box_ends (mp, mp_path_p ((mp_stroked_node) p),
              mp_pen_p ((mp_stroked_node) p), h);
@@ -13328,7 +13315,7 @@ set_number_to_inf(h->minx);
 set_number_to_inf(h->miny);
 set_number_to_neg_inf(h->maxx);
 set_number_to_neg_inf(h->maxy);
-mp_set_bbox (mp, h, false)
+mp_set_bbox (mp, h, false)@;
 
 
 @ @<Clip the bounding box in |h| to the rectangle given by |x0a|, |x1a|,...@>=
@@ -13374,8 +13361,7 @@ for cubic curve |B(t)| given by |p|,|c1|,|c2|,|q|
 and it's used for |t| near 0 and |t| near 1. We use double mode, otherwise we have to
 take care of overflow.
 
-
-@ @c
+@c
 static mp_knot mp_offset_prep (MP mp, mp_knot c, mp_knot h) {
   int n;   /* the number of vertices in the pen polygon */
   mp_knot c0, p, q, q0, r, w, ww;       /* for list manipulation */
@@ -13425,21 +13411,21 @@ static mp_knot mp_offset_prep (MP mp, mp_knot c, mp_knot h) {
   new_fraction (ss);
   new_fraction (s);
   new_fraction (t);
-  @<Initialize the pen size~|n|@>;
-  @<Initialize the incoming direction and pen offset at |c|@>;
+  @<Initialize the pen size~|n|@>@;
+  @<Initialize the incoming direction and pen offset at |c|@>
   p = c;
   c0 = c;
   k_needed = 0;
 #ifdef DEBUGENVELOPE
-dbg_nl;dbg_str(--[==[BEGIN]==]);dbg_nl;
-dbg_str(return {);dbg_nl;
+dbg_nl;dbg_str(@=--[==[BEGIN]==]@>);dbg_nl;
+dbg_str(@=return@>);dbg_nl;
 dbg_n(w0->x_coord);
 dbg_n(w0->y_coord);
 #endif
  do {
     q = mp_next_knot (p);
 #ifdef DEBUGENVELOPE
-dbg_nl;dbg_open_t;dbg_str(--[==[begin loop]==]);dbg_nl;
+dbg_nl;dbg_open_t;dbg_str(@=--[==[begin loop]==]@>);dbg_nl;
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_n(p->right_x);dbg_n(p->right_y);
 dbg_n(q->left_x);dbg_n(q->left_y);
@@ -13451,7 +13437,7 @@ dbg_n(w0->y_coord);
       associated with single offsets, after which |q| should
       point to the end of the final such cubic@>;
 #ifdef DEBUGENVELOPE
-dbg_key(end Split the cubic between |p| and |q|);dbg_open_t;dbg_nl;
+dbg_key(@=end Split the cubic between p and q@>);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 dbg_close_t; dbg_comma;dbg_nl;
@@ -13461,11 +13447,11 @@ dbg_close_t; dbg_comma;dbg_nl;
       might have been introduced by the splitting process@>;
 #ifdef DEBUGENVELOPE
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
-dbg_str(--[==[end loop]==]);dbg_nl; dbg_close_t;dbg_comma;dbg_nl;
+dbg_str(@=--[==[end loop]==]@>);dbg_nl; dbg_close_t;dbg_comma;dbg_nl;
 #endif
   } while (q != c);
 #ifdef DEBUGENVELOPE
- dbg_key(Fix the offset change);dbg_open_t;dbg_nl;
+ dbg_key(@=Fix the offset change@>);dbg_open_t;dbg_nl;
  dbg_n(p->x_coord);dbg_n(p->y_coord);
  dbg_key_ival(info pre,mp_knot_info(p));dbg_comma;dbg_nl;
  dbg_n(c->x_coord);dbg_n(c->y_coord);
@@ -13479,7 +13465,7 @@ dbg_key_ival(info post,mp_knot_info(p));dbg_comma;dbg_nl;
 dbg_n(c->x_coord);dbg_n(c->y_coord);
 dbg_key_ival(info post,mp_knot_info(c));
 dbg_close_t;
-dbg_nl;dbg_str(--[==[END]==]);dbg_nl;
+dbg_nl;dbg_str(@=--[==[END]==]@>);dbg_nl;
 #endif
   free_number (ss);
   free_number (s);
@@ -13543,7 +13529,7 @@ p = h;
 do {
   incr (n);
   p = mp_next_knot (p);
-} while (p != h)
+} while (p != h);
 
 @ Since the true incoming direction isn't known yet, we just pick a direction
 consistent with the pen offset~|h|.  If this is wrong, it can be corrected
@@ -13560,7 +13546,7 @@ later.
     set_number_from_substraction(dyin, h->x_coord, hp->x_coord);
   }
 }
-w0 = h
+w0 = h;
 
 @ We must be careful not to remove the only cubic in a cycle.
 
@@ -13574,21 +13560,20 @@ on Sarovar.)
 
 @<Advance |p| to node |q|, removing any ``dead'' cubics...@>=
 #ifdef DEBUGENVELOPE
-dbg_comment(Advance |p| to node |q|);dbg_nl;
+dbg_comment(@=Advance p to node q@>);dbg_nl;
 #endif
 q0 = q;
 do {
   r = mp_next_knot (p);
   if (number_equal (p->x_coord, p->right_x) &&
-      number_equal (p->y_coord, p->right_y) &&
+      number_equal (p->y_coord, p->right_y) && @|
       number_equal (p->x_coord, r->left_x) &&
-      number_equal (p->y_coord, r->left_y) &&
+      number_equal (p->y_coord, r->left_y) && @|
       number_equal (p->x_coord, r->x_coord) &&
-      number_equal (p->y_coord, r->y_coord) &&
-      r != p && r != q) {
+      number_equal (p->y_coord, r->y_coord) && @|
+      r != p && r != q)
     @<Remove the cubic following |p| and update the data structures
-        to merge |r| into |p|@>;
-  }
+        to merge |r| into |p|@>@;
   p = r;
 } while (p != q);
 /* Check if we removed too much */
@@ -13598,11 +13583,11 @@ if ((q != q0) && (q != c || c == c0))
 
 @ @<Remove the cubic following |p| and update the data structures...@>=
 {
- #ifdef DEBUGENVELOPE
- dbg_key(Remove the cubic following p);dbg_open_t;dbg_nl;
+#ifdef DEBUGENVELOPE
+ dbg_key(@=Remove the cubic following p@>);dbg_open_t;dbg_nl;
  dbg_n(p->x_coord);dbg_n(p->y_coord);
- dbg_key_ival(pre info p,mp_knot_info(p));  dbg_close_t;dbg_comma;dbg_nl;
- #endif
+ dbg_key_ival(pre info(p),mp_knot_info(p));  dbg_close_t;dbg_comma;dbg_nl;
+#endif
   k_needed = mp_knot_info (p) - zero_off;
   if (r == q) {
     q = p;
@@ -13620,11 +13605,11 @@ if ((q != q0) && (q != c || c == c0))
     mp->spec_p2 = p;
   r = p;
   mp_remove_cubic (mp, p);
-  #ifdef DEBUGENVELOPE
-  dbg_key(Remove the cubic following p);dbg_open_t;dbg_nl;
+#ifdef DEBUGENVELOPE
+  dbg_key(@=Remove the cubic following p@>);dbg_open_t;dbg_nl;
   dbg_n(p->x_coord);dbg_n(p->y_coord);
-  dbg_key_ival(post info p,mp_knot_info (p)); dbg_close_t;dbg_comma;dbg_nl;
-  #endif
+  dbg_key_ival(post info(p),mp_knot_info (p)); dbg_close_t;dbg_comma;dbg_nl;
+#endif
 }
 
 
@@ -13694,14 +13679,14 @@ piece corresponds to a unique offset.
 
 @<Split the cubic between |p| and |q|, if necessary, into cubics...@>=
 #ifdef DEBUGENVELOPE
-dbg_comment(Split the cubic between |p| and |q|);dbg_nl;
-dbg_key(Split the cubic);dbg_open_t;dbg_nl;
-dbg_key_ival(pre info p,mp_knot_info(p));dbg_comma;
+dbg_comment(@=Split the cubic between p and q@>);dbg_nl;
+dbg_key(@=Split the cubic@>);dbg_open_t;dbg_nl;
+dbg_key_ival(pre info(p),mp_knot_info(p));dbg_comma;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 #endif
 mp_knot_info (p) = zero_off + k_needed;
 #ifdef DEBUGENVELOPE
-dbg_key_ival(post info p,mp_knot_info(p));dbg_close_t;dbg_comma; dbg_nl;
+dbg_key_ival(post info(p),mp_knot_info(p));dbg_close_t;dbg_comma; dbg_nl;
 #endif
 k_needed = 0;
 @<Prepare for derivative computations;
@@ -13713,7 +13698,7 @@ k_needed = 0;
 @<Find the final direction |(dxin,dyin)|@>;
 @<Decide on the net change in pen offsets and set |turn_amt|@>;
 @<Complete the offset splitting process@>;
-w0 = mp_pen_walk (mp, w0, turn_amt)
+w0 = mp_pen_walk (mp, w0, turn_amt)@;
 
 
 @ @<Declarations@>=
@@ -13769,7 +13754,7 @@ set_number_from_substraction(y0, p->right_y, p->y_coord);
 set_number_from_substraction(y2, q->y_coord, q->left_y);
 set_number_from_substraction(y1, q->left_y, p->right_y);
 #ifdef DEBUGENVELOPE
-dbg_key(Prepare for derivative computations);dbg_open_t;dbg_nl;
+dbg_key(@=Prepare for derivative computations@>);dbg_open_t;dbg_nl;
 dbg_n(x0);dbg_n(y0);dbg_n(x1);dbg_n(y1);dbg_n(x2);dbg_n(y2);
 dbg_close_t;dbg_comma;dbg_nl;
 #endif
@@ -13844,15 +13829,16 @@ be set properly.  The |turn_amt| parameter gives the absolute value of the
 overall net change in pen offsets.
 
 @<Declarations@>=
-static void mp_fin_offset_prep (MP mp, mp_knot p, mp_knot w, mp_number
-                                x0, mp_number x1, mp_number x2, mp_number y0,
-                                mp_number y1, mp_number y2, integer rise,
-                                integer turn_amt);
+static void mp_fin_offset_prep (MP mp, mp_knot p, mp_knot w, @|
+                                mp_number x0, mp_number x1, mp_number x2, @|
+                                mp_number y0, mp_number y1, mp_number y2, @|
+                                integer rise, integer turn_amt);
 
 @ @c
-void mp_fin_offset_prep (MP mp, mp_knot p, mp_knot w, mp_number
-                         x0, mp_number x1, mp_number x2, mp_number y0, mp_number y1,
-                         mp_number y2, integer rise, integer turn_amt) {
+void mp_fin_offset_prep (MP mp, mp_knot p, mp_knot w, @|
+                         mp_number x0, mp_number x1, mp_number x2, @|
+                         mp_number y0, mp_number y1, mp_number y2, @|
+                         integer rise, integer turn_amt) {
   mp_knot ww;   /* for list manipulation */
   mp_number du, dv;        /* for slope calculation */
   mp_number t0, t1, t2;   /* test coefficients */
@@ -13878,7 +13864,7 @@ dbg_key(mp_fin_offset_prep);dbg_open_t;dbg_nl;
     else
       ww = mp_prev_knot (w);    /* a pointer to $w_{k-1}$ */
 #ifdef DEBUGENVELOPE
-dbg_comment(begin iteration);
+dbg_comment(@=begin iteration@>);
 dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(ww->x_coord);dbg_n(ww->y_coord);
@@ -13889,7 +13875,7 @@ dbg_in(rise);
     @<Compute test coefficients |(t0,t1,t2)|
       for $d(t)$ versus $d_k$ or $d_{k-1}$@>;
 #ifdef DEBUGENVELOPE
-dbg_comment(crossing_point);
+dbg_comment(@=crossing_point@>);
 #endif
     crossing_point (t, t0, t1, t2);
 #ifdef DEBUGENVELOPE
@@ -13905,18 +13891,18 @@ dbg_close_t; dbg_comma;dbg_nl;
         goto RETURN;
     }
 #ifdef DEBUGENVELOPE
-dbg_comment(Split the cubic at $t$ and split off another cubic if the derivative crosses back);
+dbg_comment(@=Split the cubic at t, and split off another cubic if the derivative crosses back@>);
 #endif
     @<Split the cubic at $t$,
       and split off another cubic if the derivative crosses back@>;
     w = ww;
 #ifdef DEBUGENVELOPE
-dbg_comment(end iteration);
+dbg_comment(@=end iteration@>);
 #endif
   }
 RETURN:
 #ifdef DEBUGENVELOPE
-dbg_comment(RETURN);
+dbg_comment(@=RETURN@>);
 dbg_n(t);
 #endif
   free_number (s);
@@ -13944,7 +13930,7 @@ begins to fail.
   new_number (abs_du);
   new_number (abs_dv);
 #ifdef DEBUGENVELOPE
-dbg_key(Compute test coefficients |(t0,t1,t2)| for $d(t)$ versus...);dbg_open_t;dbg_nl;
+dbg_key(@=Compute test coefficients (t0,t1,t2) for d(t) versus...@>);dbg_open_t;dbg_nl;
 #endif
   set_number_from_substraction(du, ww->x_coord, w->x_coord);
   set_number_from_substraction(dv, ww->y_coord, w->y_coord);
@@ -14069,7 +14055,7 @@ degenerate.
 @<Find the initial direction |(dx,dy)|@>=
 #ifdef DEBUGENVELOPE
 dbg_nl;
-dbg_comment(Find the initial direction |(dx,dy)|);dbg_nl;
+dbg_comment(@=Find the initial direction (dx,dy)@>);dbg_nl;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 #endif
 number_clone(dx_m, zero_t);
@@ -14111,17 +14097,17 @@ dbg_n(q->x_coord);dbg_n(q->y_coord);
 #endif
 #ifdef DEBUGENVELOPE
 dbg_close_t;dbg_comma;dbg_nl;
-dbg_key(derivatives);dbg_open_t;dbg_nl;
+dbg_key(@=derivatives@>);dbg_open_t;dbg_nl;
 dbg_n(dx_m);dbg_n(dy_m);
 dbg_n(dx);dbg_n(dy);dbg_n(dx_ap);dbg_n(dy_ap);dbg_close_t;dbg_comma;dbg_nl;
 #endif
 #ifdef DEBUGENVELOPE
-dbg_key(derivatives after first patch );dbg_open_t;dbg_nl;
+dbg_key(@=derivatives after first patch@>);dbg_open_t;dbg_nl;
 dbg_n(dx_m);dbg_n(dy_m);
 dbg_n(dx);dbg_n(dy);dbg_n(dx_ap);dbg_n(dy_ap);dbg_close_t;dbg_comma;dbg_nl;
 #endif
 #ifdef DEBUGENVELOPE
-dbg_key(derivatives patched);dbg_open_t;dbg_nl;
+dbg_key(@=derivatives patched@>);dbg_open_t;dbg_nl;
 dbg_n(dx_m);dbg_n(dy_m);
 dbg_n(dx);dbg_n(dy);dbg_n(dx_ap);dbg_n(dy_ap);dbg_close_t;dbg_comma;dbg_nl;
 #endif
@@ -14140,23 +14126,23 @@ if (number_zero(dxin) && number_zero(dyin)) {
   }
 }
 #ifdef DEBUGENVELOPE
-dbg_key(dxin dyin before);dbg_open_t;dbg_nl;
+dbg_key(@=dxin dyin before@>);dbg_open_t;dbg_nl;
 dbg_n(dxin);dbg_n(dyin);
 dbg_close_t;dbg_comma;
 #endif
 #ifdef DEBUGENVELOPE
-dbg_key(dxin dyin after);dbg_open_t;dbg_nl;
+dbg_key(@=dxin dyin after@>);dbg_open_t;dbg_nl;
 dbg_n(dxin);dbg_n(dyin);
 dbg_close_t;dbg_comma;
 #endif
 /* BEGIN PATCH */
 #ifdef DEBUGENVELOPE
-dbg_key(dx dy dxin dyin after patch);dbg_open_t;dbg_nl;
+dbg_key(@=dx dy dxin dyin after patch@>);dbg_open_t;dbg_nl;
 dbg_n(dx);dbg_n(dy);dbg_n(dx_ap);dbg_n(dy_ap);
 dbg_n(dxin);dbg_n(dyin);dbg_n(dxin_ap);dbg_n(dyin_ap);
 dbg_close_t;dbg_comma;
 #endif
-/* END PATCH ****/
+/* END PATCH */
 
 @ The next step is to bracket the initial direction between consecutive
 edges of the pen polygon.  We must be careful to turn clockwise only if
@@ -14172,8 +14158,8 @@ right.) This code depends on |w0| being the offset for |(dxin,dyin)|.
   ab_vs_cd (ab_vs_cd, dy, dxin, dx, dyin);
 #ifdef DEBUGENVELOPE
 dbg_nl;
-dbg_comment(Update |mp_knot_info(p)|);dbg_nl;
-dbg_key(mp_get_turn_amt_dx_dy);dbg_open_t;dbg_str(--[==[call mp_get_turn_amt]==]);dbg_nl;
+dbg_comment(@=Update mp_knot_info(p)@>);dbg_nl;
+dbg_key(mp_get_turn_amt_dx_dy);dbg_open_t;dbg_str(@=--[==[call mp_get_turn_amt]==]@>);dbg_nl;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);dbg_n(dx);dbg_n(dy);dbg_in(number_nonnegative(ab_vs_cd));
 dbg_n(ab_vs_cd);
 #endif
@@ -14187,7 +14173,7 @@ dbg_nl;
 #endif
   free_number (ab_vs_cd);
 #ifdef DEBUGENVELOPE
-dbg_key(w0 before walk);dbg_open_t;dbg_nl;
+dbg_key(@=w0 before walk@>);dbg_open_t;dbg_nl;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 dbg_dn(turn_amt);
 dbg_close_t;dbg_comma;
@@ -14195,7 +14181,7 @@ dbg_close_t;dbg_comma;
   w = mp_pen_walk (mp, w0, turn_amt);
   w0 = w;
 #ifdef DEBUGENVELOPE
-dbg_key(w0 after walk);dbg_open_t;dbg_nl;
+dbg_key(@=w0 after walk@>);dbg_open_t;dbg_nl;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 dbg_close_t;dbg_comma;
 dbg_open_t;dbg_in(mp_knot_info(p));
@@ -14239,7 +14225,7 @@ integer mp_get_turn_amt (MP mp, mp_knot w, mp_number dx, mp_number dy, boolean c
       ab_vs_cd (t, dy, arg1, dx, arg2);
 #ifdef DEBUGENVELOPE
      dbg_sp;
-     dbg_open_t;dbg_str(--[==[inside mp_get_turn_amt do loop ]==]);dbg_nl;
+     dbg_open_t;dbg_str(@=--[==[inside mp_get_turn_amt do loop]==]@>);dbg_nl;
      dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(ww->x_coord);dbg_n(ww->y_coord);
      dbg_n(t);dbg_n(dy);dbg_n(arg1);dbg_n(dx);dbg_n(arg2);
      dbg_n(t_ap);dbg_n(dy_ap);dbg_n(dx_ap);dbg_n(dyin_ap);dbg_n(dxin_ap);
@@ -14265,7 +14251,7 @@ integer mp_get_turn_amt (MP mp, mp_knot w, mp_number dx, mp_number dy, boolean c
     ab_vs_cd (t, dy, arg1, dx, arg2);
 #ifdef DEBUGENVELOPE
      dbg_sp;
-     dbg_open_t;dbg_str(--[==[outside mp_get_turn_amt do loop ]==]);dbg_nl;
+     dbg_open_t;dbg_str(@=--[==[outside mp_get_turn_amt do loop]==]@>);dbg_nl;
      dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(ww->x_coord);dbg_n(ww->y_coord);
      dbg_n(t);dbg_n(dy);dbg_n(arg1);dbg_n(dx);dbg_n(arg2);
      dbg_n(t_ap);dbg_n(dy_ap);dbg_n(dx_ap);dbg_n(dyin_ap);dbg_n(dxin_ap);
@@ -14281,7 +14267,7 @@ integer mp_get_turn_amt (MP mp, mp_knot w, mp_number dx, mp_number dy, boolean c
       ab_vs_cd (t, dy, arg1, dx, arg2);
 #ifdef DEBUGENVELOPE
      dbg_sp;
-     dbg_open_t;dbg_str(--[==[inside mp_get_turn_amt do loop for t<0 ]==]);dbg_nl;
+     dbg_open_t;dbg_str(@=--[==[inside mp_get_turn_amt do loop for t<0]==]@>);dbg_nl;
      dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(ww->x_coord);dbg_n(ww->y_coord);
      dbg_n(t);dbg_n(dy);dbg_n(arg1);dbg_n(dx);dbg_n(arg2);
      dbg_n(t_ap);dbg_n(dy_ap);dbg_n(dx_ap);
@@ -14335,14 +14321,14 @@ with respect to $d_{k-1}$, and apply |fin_offset_prep| to each part.
 @<Complete the offset splitting process@>=
 ww = mp_prev_knot (w);
 #ifdef DEBUGENVELOPE
-dbg_key(Complete the offset splitting process);dbg_open_t;dbg_nl;
+dbg_key(@=Complete the offset splitting process@>);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(ww->x_coord);dbg_n(ww->y_coord);
 dbg_close_t; dbg_comma;dbg_nl;
 #endif
 @<Compute test coeff...@>;
 #ifdef DEBUGENVELOPE
-dbg_key(after Compute test coeff);dbg_open_t;dbg_nl;
+dbg_key(@=after Compute test coeff@>);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(ww->x_coord);dbg_n(ww->y_coord);
 dbg_close_t; dbg_comma;dbg_nl;
@@ -14351,7 +14337,7 @@ dbg_close_t; dbg_comma;dbg_nl;
   |t:=fraction_one+1|@>;
 if (number_greater(t, fraction_one_t)) {
 #ifdef DEBUGENVELOPE
-dbg_key(t > fraction_one_t);dbg_open_t;dbg_nl;
+dbg_key(@=t > fraction_one_t@>);dbg_open_t;dbg_nl;
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(x0);dbg_n(x1);dbg_n(x2);
@@ -14369,7 +14355,7 @@ dbg_close_t; dbg_comma;dbg_nl;
   set_number_from_of_the_way(y1,  t, y1, y2);
   set_number_from_of_the_way(y2a, t, y1a, y1);
 #ifdef DEBUGENVELOPE
-dbg_key(t <= fraction_one_t);dbg_open_t;dbg_nl;
+dbg_key(@=t <= fraction_one_t@>);dbg_open_t;dbg_nl;
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_n(t);
 dbg_n(r->x_coord);dbg_n(r->y_coord);
@@ -14407,7 +14393,7 @@ dbg_close_t; dbg_comma;dbg_nl;
   }
 }
 #ifdef DEBUGENVELOPE
-dbg_key(end Complete the offset splitting process);dbg_open_t;dbg_nl;
+dbg_key(@=end Complete the offset splitting process@>);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 dbg_in(turn_amt);
@@ -14425,7 +14411,7 @@ set_number_from_of_the_way(y1,  t, y0, y1);
 set_number_from_of_the_way(y0a, t, y1, y1a);
 mp_fin_offset_prep (mp, mp_next_knot (r), w, x0a, x1a, x2, y0a, y1a, y2, 1,  turn_amt);
 number_clone(x2, x0a);
-number_clone(y2, y0a)
+number_clone(y2, y0a)@;
 
 @ At this point, the direction of the incoming pen edge is |(-du,-dv)|.
 When the component of $d(t)$ perpendicular to |(-du,-dv)| crosses zero, we
@@ -14438,7 +14424,7 @@ crossing and the first crossing cannot be antiparallel.
 
 @<Find the first |t| where $d(t)$ crosses $d_{k-1}$ or set...@>=
 #ifdef DEBUGENVELOPE
-dbg_key(Find the first |t| where);dbg_open_t;dbg_nl;
+dbg_key(@=Find the first t where@>);dbg_open_t;dbg_nl;
 #endif
 crossing_point (t, t0, t1, t2);
 if (turn_amt >= 0) {
@@ -14497,7 +14483,7 @@ the path should always change the sign of |turn_amt|.
   new_number (ab_vs_cd);
 #ifdef DEBUGENVELOPE
 dbg_sp;
-dbg_key(Decide on the net change in pen offsets and set turn_amt);dbg_open_t;dbg_nl;
+dbg_key(@=Decide on the net change in pen offsets and set turn_amt@>);dbg_open_t;dbg_nl;
 #endif
   ab_vs_cd (ab_vs_cd, dx, dyin, dxin, dy);
 #ifdef DEBUGENVELOPE
@@ -14518,9 +14504,8 @@ dbg_close_t;dbg_comma;dbg_nl;
   free_number (ab_vs_cd);
   free_number (t_ap);
 }
-if (d_sign == 0) {
-  @<Check rotation direction based on node position@>
-}
+if (d_sign == 0)
+  @<Check rotation direction based on node position@>@;
 if (d_sign == 0) {
   if (number_zero(dx)) {
     if (number_positive(dy))
@@ -14538,8 +14523,8 @@ if (d_sign == 0) {
   more than $180^\circ$@>;
 #ifdef DEBUGENVELOPE
 dbg_nl;
-dbg_key(Make |ss| negative if and only if); dbg_open_t;dbg_nl;
-dbg_key(mp_get_turn_amt_dxin_dyin);dbg_open_t;dbg_str(--[==[call mp_get_turn_amt]==]);dbg_nl; ;
+dbg_key(@=Make ss negative if and only if@>); dbg_open_t;dbg_nl;
+dbg_key(mp_get_turn_amt_dxin_dyin);dbg_open_t;dbg_str(@=--[==[call mp_get_turn_amt]==]@>);dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(dxin);dbg_n(dyin);dbg_in((d_sign > 0));
 #endif
 is_dxindyin=true;
@@ -14663,11 +14648,11 @@ if (number_positive(t0)) {
   set_number_from_addition (ss, r1, r2);
   /* BEGIN PATCH */
 #ifdef DEBUGENVELOPE
-dbg_key(patch ss before);dbg_open_t;
+dbg_key(@=patch ss before@>);dbg_open_t;
 dbg_n(ss);dbg_close_t;dbg_comma;
 #endif
 #ifdef DEBUGENVELOPE
-dbg_key(patch ss after);dbg_open_t;
+dbg_key(@=patch ss after@>);dbg_open_t;
 dbg_n(ss);dbg_close_t;dbg_comma;
 #endif
   free_number(abs_ss);
@@ -14704,9 +14689,8 @@ static void mp_print_spec (MP mp, mp_knot cur_spec, mp_knot cur_pen,
       if ((p == cur_spec) || (mp_knot_info (p) != zero_off))
         break;
     }
-    if (mp_knot_info (p) != zero_off) {
-      @<Update |w| as indicated by |mp_knot_info(p)| and print an explanation@>;
-    }
+    if (mp_knot_info (p) != zero_off)
+      @<Update |w| as indicated by |mp_knot_info(p)| and print an explanation@>@;
   } while (p != cur_spec);
   mp_print_nl (mp, " & cycle");
   mp_end_diagnostic (mp, true);
@@ -14718,12 +14702,12 @@ static void mp_print_spec (MP mp, mp_knot cur_spec, mp_knot cur_pen,
   w = mp_pen_walk (mp, w, (mp_knot_info (p) - zero_off));
   mp_print (mp, " % ");
 #ifdef DEBUGENVELOPE
- dbg_nl;dbg_open_t;dbg_str(--[==[START]==]);dbg_nl;
- dbg_key(Printing mp_knot_info (p));dbg_open_t;dbg_nl;
+ dbg_nl;dbg_open_t;dbg_str(@=--[==[START]==]@>);dbg_nl;
+ dbg_key(@=Printing mp_knot_info (p)@>);dbg_open_t;dbg_nl;
  dbg_n(p->x_coord);dbg_n(p->y_coord);
  dbg_in(mp_knot_info(p));
  dbg_close_t;dbg_close_t;dbg_comma;dbg_nl;
- dbg_nl;dbg_str(--[==[STOP]==]);dbg_nl;
+ dbg_nl;dbg_str(@=--[==[STOP]==]@>);dbg_nl;
 #endif
   if (mp_knot_info (p) > zero_off)
     mp_print (mp, "counter");
@@ -14794,9 +14778,8 @@ static mp_knot mp_make_envelope (MP mp, mp_knot c, mp_knot h, quarterword ljoin,
     k = mp_knot_info (q);
     k0 = k;
     w0 = w;
-    if (k != zero_off) {
-      @<Set |join_type| to indicate how to handle offset changes at~|q|@>;
-    }
+    if (k != zero_off)
+      @<Set |join_type| to indicate how to handle offset changes at~|q|@>@;
     @<Add offset |w| to the cubic from |p| to |q|@>;
     while (k != zero_off) {
       @<Step |w| and move |k| one step closer to |zero_off|@>;
@@ -14811,10 +14794,9 @@ static mp_knot mp_make_envelope (MP mp, mp_knot c, mp_knot h, quarterword ljoin,
 	free_number (ytot);
       }
     }
-    if (q != mp_next_knot (p)) {
+    if (q != mp_next_knot (p))
       @<Set |p=mp_link(p)| and add knots between |p| and |q| as
-        required by |join_type|@>;
-    }
+        required by |join_type|@>@;
     p = q;
   } while (q0 != c);
   free_number (max_ht);
@@ -14843,26 +14825,26 @@ degenerate cubic.  Setting |join_type:=2| in this case makes the computed
 envelope degenerate as well.
 
 @<Set |join_type| to indicate how to handle offset changes at~|q|@>=
-if (k < zero_off) {
-  join_type = 2;
-} else {
-  if ((q != mp->spec_p1) && (q != mp->spec_p2))
-    join_type = ljoin;
-  else if (lcap == 2)
-    join_type = 3;
-  else
-    join_type = 2 - lcap;
-  if ((join_type == 0) || (join_type == 3)) {
-    @<Set the incoming and outgoing directions at |q|; in case of
-      degeneracy set |join_type:=2|@>;
-    if (join_type == 0) {
-      @<If |miterlim| is less than the secant of half the angle at |q|
-        then set |join_type:=2|@>;
+{
+  if (k < zero_off) {
+    join_type = 2;
+  } else {
+    if ((q != mp->spec_p1) && (q != mp->spec_p2))
+      join_type = ljoin;
+    else if (lcap == 2)
+      join_type = 3;
+    else
+      join_type = 2 - lcap;
+    if ((join_type == 0) || (join_type == 3)) {
+      @<Set the incoming and outgoing directions at |q|; in case of
+        degeneracy set |join_type:=2|@>;
+      if (join_type == 0)
+        @<If |miterlim| is less than the secant of half the angle at |q|
+          then set |join_type:=2|@>@;
     }
   }
 }
 
-
 @ @<If |miterlim| is less than the secant of half the angle at |q|...@>=
 {
   mp_number r1, r2;
@@ -14901,7 +14883,7 @@ number_add (q->left_y,  w->y_coord);
 number_add (q->x_coord, w->x_coord);
 number_add (q->y_coord, w->y_coord);
 mp_left_type (q) = mp_explicit;
-mp_right_type (q) = mp_explicit
+mp_right_type (q) = mp_explicit@;
 
 @ @<Step |w| and move |k| one step closer to |zero_off|@>=
 if (k > zero_off) {
@@ -14948,12 +14930,11 @@ mp_knot mp_insert_knot (MP mp, mp_knot q, mp_number x, mp_number y) {
 {
   p = mp_next_knot (p);
   if ((join_type == 0) || (join_type == 3)) {
-    if (join_type == 0) {
-      @<Insert a new knot |r| between |p| and |q| as required for a mitered join@>
-    } else {
+    if (join_type == 0)
+      @<Insert a new knot |r| between |p| and |q| as required for a mitered join@>@;
+    else
       @<Make |r| the last of two knots inserted between |p| and |q| to form a
-        squared join@>;
-    }
+        squared join@>@;
     if (r != NULL) {
       number_clone (r->right_x, r->x_coord);
       number_clone (r->right_y, r->y_coord);
@@ -15141,9 +15122,8 @@ if (mp_left_type (c) == mp_endpoint) {
   if (c != mp_next_knot (c)) {
     mp_originator (mp->spec_p2) = mp_program_code;
     mp_remove_cubic (mp, mp->spec_p2);
-  } else {
-    @<Make |c| look like a cycle of length one@>;
-  }
+  } else
+    @<Make |c| look like a cycle of length one@>@;
 }
 
 @ @<Make |c| look like a cycle of length one@>=
@@ -15193,7 +15173,7 @@ That knot is |p| but if |p<>c|, its coordinates have already been offset by |w|.
 
 
 @ If |q=c| then the coordinates of |r| and the control points between |q|
-and~|r| have already been offset by |h|.
+and~|r| have already been offset by~|h|.
 
 @<Set the outgoing direction at |q|@>=
 {
@@ -15215,7 +15195,7 @@ and~|r| have already been offset by |h|.
   pyth_add (tmp, dxout, dyout);
   if (number_zero(tmp)) {
     /* |mp_confusion (mp, "degenerate spec");| */
-@:this can't happen degerate spec}{\quad degenerate spec@>;
+@:this can't happen degenerate spec}{\quad degenerate spec@>
     /* But apparently, it actually can happen. The test case is this:
 
   path p;
@@ -15821,7 +15801,7 @@ if (int_packets + (17+2) * int_increment > bistack_size)
 @ Computation of the min and max is a tedious but fairly fast sequence of
 instructions; exactly four comparisons are made in each branch.
 
-@d set_min_max(A)
+@d set_min_max(A) @/
   debug_number (stack_1(A));
   debug_number (stack_3(A));
   debug_number (stack_2(A));
@@ -15920,10 +15900,10 @@ static void mp_cubic_intersection (MP mp, mp_knot p, mp_knot pp) {
 CONTINUE:
   while (1) {
     /* When we are in arbitrary precision math, low precisions can */
-    /* lead to acces locations beyond the |stack_size|: in this case */
+    /* lead to access locations beyond the |stack_size|: in this case */
     /* we say that there is no intersection.*/
     if ( ((x_packet (mp->xy))+4)>bistack_size ||
-         ((u_packet (mp->uv))+4)>bistack_size ||
+         ((u_packet (mp->uv))+4)>bistack_size || @|
     	 ((y_packet (mp->xy))+4)>bistack_size ||
          ((v_packet (mp->uv))+4)>bistack_size ){
     	 set_number_from_scaled (mp->cur_t, 1);
@@ -15980,21 +15960,18 @@ CONTINUE:
     if (odd (number_to_scaled (mp->cur_tt))) {
       if (odd (number_to_scaled (mp->cur_t))) {
         /* Descend to the previous level and |goto not_found| */
-        {
-          set_number_from_scaled (mp->cur_t, half (number_to_scaled (mp->cur_t)));
-          set_number_from_scaled (mp->cur_tt, half (number_to_scaled (mp->cur_tt)));
-          if (number_to_scaled (mp->cur_t) == 0)
-            return;
-          mp->bisect_ptr -= int_increment;
-          mp->three_l -= (integer) mp->tol_step;
-          number_clone (mp->delx, stack_dx);
-          number_clone (mp->dely, stack_dy);
-          mp->tol = number_to_scaled (stack_tol);
-          mp->uv = number_to_scaled (stack_uv);
-          mp->xy = number_to_scaled (stack_xy);
-          goto NOT_FOUND;
-        }
-
+        set_number_from_scaled (mp->cur_t, half (number_to_scaled (mp->cur_t)));
+        set_number_from_scaled (mp->cur_tt, half (number_to_scaled (mp->cur_tt)));
+        if (number_to_scaled (mp->cur_t) == 0)
+          return;
+        mp->bisect_ptr -= int_increment;
+        mp->three_l -= (integer) mp->tol_step;
+        number_clone (mp->delx, stack_dx);
+        number_clone (mp->dely, stack_dy);
+        mp->tol = number_to_scaled (stack_tol);
+        mp->uv = number_to_scaled (stack_uv);
+        mp->xy = number_to_scaled (stack_xy);
+        goto NOT_FOUND;
       } else {
         set_number_from_scaled (mp->cur_t, number_to_scaled (mp->cur_t) + 1);
         number_add (mp->delx, stack_1 (u_packet (mp->uv)));
@@ -16085,11 +16062,9 @@ mp->uv = r_packets;
 mp->xy = r_packets;
 mp->three_l = 0;
 set_number_from_scaled (mp->cur_t, 1);
-set_number_from_scaled (mp->cur_tt, 1)
+set_number_from_scaled (mp->cur_tt, 1)@;
 
-@
-
-@<Subdivide for a new level of intersection@>=
+@ @<Subdivide for a new level of intersection@>=
 number_clone (stack_dx, mp->delx);
 number_clone (stack_dy, mp->dely);
 set_number_from_scaled (stack_tol, mp->tol);
@@ -16136,7 +16111,7 @@ number_double(mp->delx);
 number_double(mp->dely);
 mp->tol = mp->tol - mp->three_l + (integer) mp->tol_step;
 mp->tol += mp->tol;
-mp->three_l = mp->three_l + (integer) mp->tol_step
+mp->three_l = mp->three_l + (integer) mp->tol_step@;
 
 @ The |path_intersection| procedure is much simpler.
 It invokes |cubic_intersection| in lexicographic order until finding a
@@ -16308,19 +16283,19 @@ structures have to match.
    mp_value_node d = (mp_value_node)(B);
    FUNCTION_TRACE4("set_dep_info(%p,%p) on %d\n",(A),d,__LINE__);
   ((mp_value_node)(A))->parent_ = (mp_node)d;
-} while (0)
+} while (0)@;
 @d dep_list(A) ((mp_value_node)(A))->attr_head_  /* half of the |value| field in a |dependent| variable */
 @d set_dep_list(A,B) do {
    mp_value_node d = (mp_value_node)(B);
    FUNCTION_TRACE4("set_dep_list(%p,%p) on %d\n",(A),d,__LINE__);
    dep_list((A)) = (mp_node)d;
-} while (0)
+} while (0)@;
 @d prev_dep(A) ((mp_value_node)(A))->subscr_head_ /* the other half; makes a doubly linked list */
 @d set_prev_dep(A,B) do {
    mp_value_node d = (mp_value_node)(B);
    FUNCTION_TRACE4("set_prev_dep(%p,%p) on %d\n",(A),d,__LINE__);
    prev_dep((A)) = (mp_node)d;
-} while (0)
+} while (0)@;
 
 @c
 static mp_node get_dep_info (MP mp, mp_value_node p) {
@@ -16339,9 +16314,7 @@ static void do_set_dep_value (MP mp, mp_value_node p, mp_number q) {
 @ @<Declarations...@>=
 static mp_node get_dep_info (MP mp, mp_value_node p);
 
-@
-
-@c
+@ @c
 static mp_value_node mp_get_dep_node (MP mp) {
   mp_value_node p = (mp_value_node) mp_get_value_node (mp);
   mp_type (p) = mp_dep_node_type;
@@ -16834,8 +16807,7 @@ by a given |scaled| constant.
 static mp_value_node mp_p_over_v (MP mp, mp_value_node p, mp_number v, quarterword
                                   t0, quarterword t1);
 
-@
-@d p_over_v_threshold_k ((math_data *)mp->math)->p_over_v_threshold_t
+@ @d p_over_v_threshold_k ((math_data *)mp->math)->p_over_v_threshold_t
 
 @c
 mp_value_node mp_p_over_v (MP mp, mp_value_node p, mp_number v_orig, quarterword
@@ -16970,7 +16942,7 @@ static void mp_val_too_big (MP mp, mp_number x) {
     char msg[256];
     const char *hlp[] = {
            "The equation I just processed has given some variable a",
-           "value outside of the safetyp range. Continue and I'll try",
+           "value outside of the safety range. Continue and I'll try",
            "to cope with that big value; but it might be dangerous.",
            "(Set warningcheck:=0 to suppress this message.)",
            NULL };
@@ -17029,8 +17001,7 @@ to zero, so that a variable will become known more or less by default.
 @<Declarations@>=
 static void mp_fix_dependencies (MP mp);
 
-@
-@d independent_being_fixed 1 /* this variable already appears in |s| */
+@ @d independent_being_fixed 1 /* this variable already appears in |s| */
 @c
 static void mp_fix_dependencies (MP mp) {
   mp_value_node p, q, r, s, t;  /* list manipulation registers */
@@ -17232,8 +17203,7 @@ static void mp_linear_eq (MP mp, mp_value_node p, quarterword t) {
 }
 
 
-@
-@c
+@ @c
 static mp_value_node find_node_with_largest_coefficient(MP mp, mp_value_node p, mp_number *v) {
   mp_number vabs; /* its absolute value of v*/
   mp_number rabs; /* the absolute value of |dep_value(r)| */
@@ -17317,8 +17287,7 @@ static mp_value_node divide_p_by_minusv_removing_q (MP mp, mp_value_node p, mp_v
 }
 
 
-@
-@c
+@ @c
 static void display_new_dependency (MP mp, mp_value_node p, mp_node x, integer n) {
   if (mp_interesting (mp, x)) {
     int w0;
@@ -17378,8 +17347,7 @@ static mp_value_node divide_p_by_2_n (MP mp, mp_value_node p, integer n) {
   return pp;
 }
 
-@
-@c
+@ @c
 static void change_to_known (MP mp, mp_value_node p, mp_node x, mp_value_node final_node, integer n) {
   if (dep_info (p) == NULL) {
     mp_number absx;
@@ -17527,7 +17495,7 @@ static void mp_ring_merge (MP mp, mp_node p, mp_node q) {
     if (r == q) {
       exclaim_redundant_equation(mp);
       return;
-    };
+    }
     r = value_node (r);
   }
   r = value_node (p);
@@ -17630,7 +17598,7 @@ static void mp_print_cmd_mod (MP mp, integer c, integer m);
 @ @c
 void mp_print_cmd_mod (MP mp, integer c, integer m) {
   switch (c) {
-    @<Cases of |print_cmd_mod| for symbolic printing of primitives@>
+    @t\4@>@<Cases of |print_cmd_mod| for symbolic printing of primitives@>@;
   default:
     mp_print (mp, "[unknown command code!]");
     break;
@@ -17942,8 +17910,8 @@ integer mp_true_line (MP mp) {
     return line;
   } else {
     k = mp->input_ptr;
-    while ((k > 0) &&
-           ((mp->input_stack[(k - 1)].index_field < file_bottom) ||
+    while ((k > 0) && @|
+           ((mp->input_stack[(k - 1)].index_field < file_bottom) || @|
             (mp->input_stack[(k - 1)].name_field <= max_spec_src))) {
       decr (k);
     }
@@ -18222,7 +18190,7 @@ new level (having, initially, the same properties as the old).
     mp->max_in_stack=mp->input_ptr;
     if ( mp->input_ptr==mp->stack_size ) {
         int l = (mp->stack_size+(mp->stack_size/4));
-        /* The mp->stack\_size < 1001 condition is necessary to prevent C stack overflow due infinite recursion. */
+        /* The |mp->stack_size < 1001| condition is necessary to prevent C stack overflow due infinite recursion. */
         if (l>1000) {fprintf(stderr, "input stack overflow\n");exit(EXIT_FAILURE);}
         XREALLOC(mp->input_stack, l, in_state_record);
         mp->stack_size = l;
@@ -18408,7 +18376,7 @@ static void mp_end_file_reading (MP mp) {
   if (mp->in_open > iindex) {
     if ((mp->mpx_name[mp->in_open] == absent) || (name <= max_spec_src)) {
       mp_confusion (mp, "endinput");
-@:this can't happen endinput}{\quad endinput@>;
+@:this can't happen endinput}{\quad endinput@>
     } else {
       (mp->close_file) (mp, mp->input_file[mp->in_open]);       /* close an \.{MPX} file */
       delete_str_ref (mp->mpx_name[mp->in_open]);
@@ -18467,7 +18435,7 @@ static boolean mp_begin_mpx_reading (MP mp) {
 static void mp_end_mpx_reading (MP mp) {
   if (mp->in_open != iindex)
     mp_confusion (mp, "mpx");
-@:this can't happen mpx}{\quad mpx@>;
+@:this can't happen mpx}{\quad mpx@>
   if (loc < limit) {
     /* Complain that we are not at the end of a line in the \.{MPX} file */
     /* Here we enforce a restriction that simplifies the input stacks considerably.
@@ -18596,7 +18564,7 @@ static boolean mp_check_outer_validity (MP mp) {
              "the matching `fi'. I've inserted a `fi'; this might work.",
              NULL };
       mp_snprintf(msg, 256, "Incomplete if; all text was ignored after line %d", (int)mp->warning_line);
-@.Incomplete if...@>;
+@.Incomplete if...@>
       if (cur_sym() == NULL) {
         hlp[0] = "The file ended while I was skipping conditional text.";
       }
@@ -18652,7 +18620,7 @@ if (cur_sym() != NULL) {
   }
   switch (mp->scanner_status) {
     @<Complete the error message,
-      and set |cur_sym| to a token that might help recover from the error@>
+      and set |cur_sym| to a token that might help recover from the error@>@;
   }                             /* there are no other cases */
   mp_ins_error (mp, msg, hlp, true);
 }
@@ -18745,7 +18713,7 @@ static void mp_firm_up_the_line (MP mp);
 
 @ And now we're ready to take the plunge into |get_next| itself.
 Note that the behavior depends on the |scanner_status| because percent signs
-and double quotes need to be passed over when skipping TeX material.
+and double quotes need to be passed over when skipping \TeX\ material.
 
 @c
 void mp_get_next (MP mp) {
@@ -18948,13 +18916,13 @@ static int move_to_next_line (MP mp) {
           mp_firm_up_the_line (mp); /* this sets |limit| */
         else
           mp->force_eof = true;
-      };
+      }
       if (mp->force_eof) {
         mp->force_eof = false;
         decr (loc);
         if (mpx_reading) {
-          /* Complain that the \.{MPX} file ended unexpectly; then set
-            |cur_sym:=mp->frozen_mpx_break| and |goto comon_ending| */
+          /* Complain that the \.{MPX} file ended unexpectedly; then set
+            |cur_sym:=mp->frozen_mpx_break| and |goto common_ending| */
 	  /* We should never actually come to the end of an \.{MPX} file because such
              files should have an \&{mpxbreak} after the translation of the last
              \&{btex}$\,\ldots\,$\&{etex} block. */
@@ -19038,7 +19006,7 @@ void mp_firm_up_the_line (MP mp) {
     }
     mp->first = (size_t) limit;
     prompt_input ("=>");        /* wait for user response */
-@.=>@>;
+@.=>@>
     if (mp->last > mp->first) {
       for (k = mp->first; k < mp->last; k++) {  /* move line down in buffer */
         mp->buffer[k + (size_t) start - mp->first] = mp->buffer[k];
@@ -19052,7 +19020,7 @@ void mp_firm_up_the_line (MP mp) {
 @* Dealing with \TeX\ material.
 The \&{btex}$\,\ldots\,$\&{etex} and \&{verbatimtex}$\,\ldots\,$\&{etex}
 features need to be implemented at a low level in the scanning process
-so that \MP\ can stay in synch with the a preprocessor that treats
+so that \MP\ can stay in sync with the a preprocessor that treats
 blocks of \TeX\ material as they occur in the input file without trying
 to expand \MP\ macros.  Thus we need a special version of |get_next|
 that does not expand macros and such but does handle \&{btex},
@@ -19068,12 +19036,12 @@ $\,\ldots\,$\&{etex} blocks, switching to the \.{MPX} file when it sees
 
 @ @<Put each...@>=
 mp_primitive (mp, "btex", mp_start_tex, btex_code);
-@:btex_}{\&{btex} primitive@>;
+@:btex_}{\&{btex} primitive@>
 mp_primitive (mp, "verbatimtex", mp_start_tex, verbatim_code);
-@:verbatimtex_}{\&{verbatimtex} primitive@>;
+@:verbatimtex_}{\&{verbatimtex} primitive@>
 mp_primitive (mp, "etex", mp_etex_marker, 0);
 mp->frozen_etex = mp_frozen_primitive (mp, "etex", mp_etex_marker, 0);
-@:etex_}{\&{etex} primitive@>;
+@:etex_}{\&{etex} primitive@>
 mp_primitive (mp, "mpxbreak", mp_mpx_break, 0);
 mp->frozen_mpx_break = mp_frozen_primitive (mp, "mpxbreak", mp_mpx_break, 0);
 @:mpx_break_}{\&{mpxbreak} primitive@>
@@ -19101,9 +19069,8 @@ is encountered.
   mp_get_next (mp);
   if (cur_cmd() <= mp_max_pre_command)
     mp_t_next (mp);
-} while (0)
+} while (0)@;
 
-@c
 @ @<Declarations@>=
 static void mp_t_next (MP mp);
 static void mp_start_mpx_input (MP mp);
@@ -19113,33 +19080,32 @@ static void mp_t_next (MP mp) {
   int old_status;       /* saves the |scanner_status| */
   integer old_info;     /* saves the |warning_info| */
 
-if ((mp->extensions == 1) && (cur_cmd() == mp_start_tex)) {
-    @<Pass btex ... etex to script@>;
-} else {
+if ((mp->extensions == 1) && (cur_cmd() == mp_start_tex))
+    @<Pass \&{btex} ... \&{etex} to script@>@;
+else {
 
     while (cur_cmd() <= mp_max_pre_command) {
         if (cur_cmd() == mp_mpx_break) {
-          if (!file_state || (mp->mpx_name[iindex] == absent)) {
-            @<Complain about a misplaced \&{mpxbreak}@>;
-          } else {
+          if (!file_state || (mp->mpx_name[iindex] == absent))
+            @<Complain about a misplaced \&{mpxbreak}@>@;
+          else {
             mp_end_mpx_reading (mp);
             goto TEX_FLUSH;
           }
         } else if (cur_cmd() == mp_start_tex) {
-          if (token_state || (name <= max_spec_src)) {
-            @<Complain that we are not reading a file@>;
-          } else if (mpx_reading) {
-            @<Complain that \.{MPX} files cannot contain \TeX\ material@>;
-          } else if ((cur_mod() != verbatim_code) &&
+          if (token_state || (name <= max_spec_src))
+            @<Complain that we are not reading a file@>@;
+          else if (mpx_reading)
+            @<Complain that \.{MPX} files cannot contain \TeX\ material@>@;
+          else if ((cur_mod() != verbatim_code) &&
                      (mp->mpx_name[iindex] != mpx_finished)) {
             if (!mp_begin_mpx_reading (mp))
               mp_start_mpx_input (mp);
           } else {
             goto TEX_FLUSH;
           }
-        } else {
-          @<Complain about a misplaced \&{etex}@>;
-        }
+        } else
+          @<Complain about a misplaced \&{etex}@>@;
         goto COMMON_ENDING;
       TEX_FLUSH:
         @<Flush the \TeX\ material@>;
@@ -19163,7 +19129,7 @@ do {
   mp_get_next (mp);
 } while (cur_cmd() != mp_etex_marker);
 mp->scanner_status = old_status;
-mp->warning_line = old_info
+mp->warning_line = old_info@;
 
 @ @<Complain that \.{MPX} files cannot contain \TeX\ material@>=
 {
@@ -19226,24 +19192,24 @@ like \&{enddef} and \&{endfor}.
 
 @<Put each...@>=
 mp_primitive (mp, "def", mp_macro_def, start_def);
-@:def_}{\&{def} primitive@>;
+@:def_}{\&{def} primitive@>
 mp_primitive (mp, "vardef", mp_macro_def, var_def);
-@:var_def_}{\&{vardef} primitive@>;
+@:var_def_}{\&{vardef} primitive@>
 mp_primitive (mp, "primarydef", mp_macro_def, mp_secondary_primary_macro);
-@:primary_def_}{\&{primarydef} primitive@>;
+@:primary_def_}{\&{primarydef} primitive@>
 mp_primitive (mp, "secondarydef", mp_macro_def, mp_tertiary_secondary_macro);
-@:secondary_def_}{\&{secondarydef} primitive@>;
+@:secondary_def_}{\&{secondarydef} primitive@>
 mp_primitive (mp, "tertiarydef", mp_macro_def, mp_expression_tertiary_macro);
-@:tertiary_def_}{\&{tertiarydef} primitive@>;
+@:tertiary_def_}{\&{tertiarydef} primitive@>
 mp_primitive (mp, "enddef", mp_macro_def, end_def);
 mp->frozen_end_def = mp_frozen_primitive (mp, "enddef", mp_macro_def, end_def);
-@:end_def_}{\&{enddef} primitive@>;
+@:end_def_}{\&{enddef} primitive@>
 mp_primitive (mp, "for", mp_iteration, start_for);
-@:for_}{\&{for} primitive@>;
+@:for_}{\&{for} primitive@>
 mp_primitive (mp, "forsuffixes", mp_iteration, start_forsuffixes);
-@:for_suffixes_}{\&{forsuffixes} primitive@>;
+@:for_suffixes_}{\&{forsuffixes} primitive@>
 mp_primitive (mp, "forever", mp_iteration, start_forever);
-@:forever_}{\&{forever} primitive@>;
+@:forever_}{\&{forever} primitive@>
 mp_primitive (mp, "endfor", mp_iteration, end_for);
 mp->frozen_end_for = mp_frozen_primitive (mp, "endfor", mp_iteration, end_for);
 @:end_for_}{\&{endfor} primitive@>
@@ -19307,8 +19273,7 @@ typedef struct mp_subst_list_item {
   struct mp_subst_list_item *link;
 } mp_subst_list_item;
 
-@
-@c
+@ @c
 static mp_node mp_scan_toks (MP mp, mp_command_code terminator,
                              mp_subst_list_item * subst_list, mp_node tail_end,
                              quarterword suffix_count) {
@@ -19325,9 +19290,9 @@ static mp_node mp_scan_toks (MP mp, mp_command_code terminator,
     cur_data = -1;
     if (cur_sym() != NULL) {
       @<Substitute for |cur_sym|, if it's on the |subst_list|@>;
-      if (cur_cmd() == terminator) {
-        @<Adjust the balance; |break| if it's zero@>;
-      } else if (cur_cmd() == mp_macro_special) {
+      if (cur_cmd() == terminator)
+        @<Adjust the balance; |break| if it's zero@>@;
+      else if (cur_cmd() == mp_macro_special) {
         /* Handle quoted symbols, \.{\#\AT!}, \.{\AT!}, or \.{\AT!\#} */
         if (cur_mod() == quote) {
           get_t_next (mp);
@@ -19356,8 +19321,7 @@ static mp_node mp_scan_toks (MP mp, mp_command_code terminator,
   return mp_link (mp->hold_head);
 }
 
-@
-@c
+@ @c
 void mp_print_sym  (mp_sym sym) {
   printf("{type = %d, v = {type = %d, data = {indep = {scale = %d, serial = %d}, n = %d, str = %p, sym = %p, node = %p, p = %p}}, text = %p}\n", 
     sym->type, sym->v.type, (int)sym->v.data.indep.scale, (int)sym->v.data.indep.serial,
@@ -19372,8 +19336,7 @@ void mp_print_sym  (mp_sym sym) {
   }
 }
 
-@
-@<Declarations@>=
+@ @<Declarations@>=
 void mp_print_sym  (mp_sym sym) ;
 
 @ @<Substitute for |cur_sym|...@>=
@@ -19392,15 +19355,16 @@ void mp_print_sym  (mp_sym sym) ;
 
 
 @ @<Adjust the balance; |break| if it's zero@>=
-if (cur_mod() > 0) {
-  incr (balance);
-} else {
-  decr (balance);
-  if (balance == 0)
-    break;
+{
+  if (cur_mod() > 0) {
+    incr (balance);
+  } else {
+    decr (balance);
+    if (balance == 0)
+      break;
+  }
 }
 
-
 @ Four commands are intended to be used only within macro texts: \&{quote},
 \.{\#\AT!}, \.{\AT!}, and \.{\AT!\#}. They are variants of a single command
 code called |macro_special|.
@@ -19412,11 +19376,11 @@ code called |macro_special|.
 
 @<Put each...@>=
 mp_primitive (mp, "quote", mp_macro_special, quote);
-@:quote_}{\&{quote} primitive@>;
+@:quote_}{\&{quote} primitive@>
 mp_primitive (mp, "#@@", mp_macro_special, macro_prefix);
-@:]]]\#\AT!_}{\.{\#\AT!} primitive@>;
+@:]]]\#\AT!_}{\.{\#\AT!} primitive@>
 mp_primitive (mp, "@@", mp_macro_special, macro_at);
-@:]]]\AT!_}{\.{\AT!} primitive@>;
+@:]]]\AT!_}{\.{\AT!} primitive@>
 mp_primitive (mp, "@@#", mp_macro_special, macro_suffix);
 @:]]]\AT!\#_}{\.{\AT!\#} primitive@>
 
@@ -19460,7 +19424,7 @@ RESTART:
       delete_str_ref (cur_mod_str());
     set_cur_sym(mp->frozen_inaccessible);
     mp_ins_error (mp, "Missing symbolic token inserted", hlp, true);
-@.Missing symbolic token...@>;
+@.Missing symbolic token...@>
     goto RESTART;
   }
 }
@@ -19492,7 +19456,7 @@ static void mp_check_equals (MP mp) {
              "will be the replacement text of this macro.",
              NULL };
       mp_back_error (mp, "Missing `=' has been inserted", hlp, true);
-@.Missing `='@>;
+@.Missing `='@>
     }
 }
 
@@ -19545,15 +19509,15 @@ static void mp_make_op_def (MP mp) {
 
 @<Put each...@>=
 mp_primitive (mp, "expr", mp_param_type, mp_expr_param);
-@:expr_}{\&{expr} primitive@>;
+@:expr_}{\&{expr} primitive@>
 mp_primitive (mp, "suffix", mp_param_type, mp_suffix_param);
-@:suffix_}{\&{suffix} primitive@>;
+@:suffix_}{\&{suffix} primitive@>
 mp_primitive (mp, "text", mp_param_type, mp_text_param);
-@:text_}{\&{text} primitive@>;
+@:text_}{\&{text} primitive@>
 mp_primitive (mp, "primary", mp_param_type, mp_primary_macro);
-@:primary_}{\&{primary} primitive@>;
+@:primary_}{\&{primary} primitive@>
 mp_primitive (mp, "secondary", mp_param_type, mp_secondary_macro);
-@:secondary_}{\&{secondary} primitive@>;
+@:secondary_}{\&{secondary} primitive@>
 mp_primitive (mp, "tertiary", mp_param_type, mp_tertiary_macro);
 @:tertiary_}{\&{tertiary} primitive@>
 
@@ -19578,10 +19542,10 @@ break;
 and \&{vardef}. When the following procedure is called, |cur_mod|
 should be either |start_def| or |var_def|.
 
-Note that although the macro scanner allows |def = := enddef| and
-|def := = enddef|; |def = = enddef| and |def := := enddef| will generate
-an error because by the time the second of the two identical tokens is
-seen, its meaning has already become undefined.
+Note that although the macro scanner allows \&{def} = := \&{enddef} and
+\&{def} := = \&{enddef}; \&{def} = = \&{enddef} and \&{def} := := \&{enddef}
+will generate an error because by the time the second of the two identical
+tokens is seen, its meaning has already become undefined.
 
 @c
 static void mp_scan_def (MP mp) {
@@ -19797,7 +19761,7 @@ static void mp_stop_iteration (MP mp);
 (Near) infinite recursion is a problem because it translates into
 C function calls that eat up the available call stack. A better solution
 would be to depend on signal trapping, but that is problematic when
-Metapost is used as a library.
+\MP\ is used as a library.
 
 @<Global...@>=
 int expand_depth_count; /* current expansion depth */
@@ -19849,7 +19813,7 @@ static void mp_expand (MP mp) {
       show_cur_cmd_mod;
   switch (cur_cmd()) {
   case mp_if_test:
-    mp_conditional (mp);        /* this procedure is discussed in Part 36 below */
+    mp_conditional (mp);        /* this procedure is discussed in Part ``Conditional processing'' below */
     break;
   case mp_fi_or_else:
     @<Terminate the current conditional and skip to \&{fi}@>;
@@ -19858,10 +19822,10 @@ static void mp_expand (MP mp) {
     @<Initiate or terminate input from a file@>;
     break;
   case mp_iteration:
-    if (cur_mod() == end_for) {
-      @<Scold the user for having an extra \&{endfor}@>;
-    } else {
-      mp_begin_iteration (mp);  /* this procedure is discussed in Part 37 below */
+    if (cur_mod() == end_for)
+      @<Scold the user for having an extra \&{endfor}@>@;
+    else {
+      mp_begin_iteration (mp);  /* this procedure is discussed in Part ``Iterations'' below */
     }
     break;
   case mp_repeat_loop:
@@ -19889,7 +19853,7 @@ static void mp_expand (MP mp) {
     break;
   default:
     break; /* make the compiler happy */
-  };                            /* there are no other cases */
+  }                            /* there are no other cases */
   mp->expand_depth_count--;
 }
 
@@ -19901,16 +19865,16 @@ static void mp_expand (MP mp) {
          "so I had better not try to end anything.",
          NULL };
   mp_error (mp, "Extra `endfor'", hlp, true);
-@.Extra `endfor'@>;
+@.Extra `endfor'@>
 }
 
 
-@ The processing of \&{input} involves the |start_input| subroutine,
+@ The processing of \&{input} involves the |mp_start_input| subroutine,
 which will be declared later; the processing of \&{endinput} is trivial.
 
 @<Put each...@>=
 mp_primitive (mp, "input", mp_input, 0);
-@:input_}{\&{input} primitive@>;
+@:input_}{\&{input} primitive@>
 mp_primitive (mp, "endinput", mp_input, 1);
 @:end_input_}{\&{endinput} primitive@>
 
@@ -19944,9 +19908,9 @@ that will be |NULL| if no loop is in progress.
            "to want to repeat it. I'll try to forget the problem.",
            NULL };
     mp_error (mp, "Lost loop", hlp, true);
-@.Lost loop@>;
+@.Lost loop@>
   } else {
-    mp_resume_iteration (mp);   /* this procedure is in Part 37 below */
+    mp_resume_iteration (mp);   /* this procedure is in Part ``Iterations'' below */
   }
 }
 
@@ -19965,17 +19929,16 @@ that will be |NULL| if no loop is in progress.
         mp_error (mp, "No loop is in progress", hlp, true);
       else
         mp_back_error (mp, "No loop is in progress", hlp, true);
-@.No loop is in progress@>;
-    } else {
-      @<Exit prematurely from an iteration@>;
-    }
+@.No loop is in progress@>
+    } else
+      @<Exit prematurely from an iteration@>@;
   } else if (cur_cmd() != mp_semicolon) {
     const char *hlp[] = {
            "After `exitif <boolean exp>' I expect to see a semicolon.",
            "I shall pretend that one was there.",
            NULL };
     mp_back_error (mp, "Missing `;' has been inserted", hlp, true);
-@.Missing `;'@>;
+@.Missing `;'@>
   }
 }
 
@@ -19997,8 +19960,8 @@ is less than |loop_text|.
   } while (p == NULL);
   if (p != mp->loop_ptr->info)
     mp_fatal_error (mp, "*** (loop confusion)");
-@.loop confusion@>;
-  mp_stop_iteration (mp);       /* this procedure is in Part 34 below */
+@.loop confusion@>
+  mp_stop_iteration (mp);       /* this procedure is in Part ``Iterations'' below */
 }
 
 
@@ -20030,7 +19993,7 @@ is less than |loop_text|.
     new_number(new_expr.data.n);
     mp_disp_err (mp, NULL);
     mp_back_error (mp, "Not a string", hlp, true);
-@.Not a string@>;
+@.Not a string@>
     mp_get_x_next (mp);
     mp_flush_cur_exp (mp, new_expr);
   } else {
@@ -20083,28 +20046,29 @@ if (s != NULL) {
         new_number(new_expr.data.n);
         mp_disp_err (mp, NULL);
         mp_back_error (mp, "Not a string", hlp, true);
-        @.Not a string@>;
+        @.Not a string@>
         mp_get_x_next (mp);
         mp_flush_cur_exp (mp, new_expr);
     } else {
         mp_back_input (mp);
         if (cur_exp_str ()->len > 0) {
             char *s = mp->run_script(mp,(const char*) cur_exp_str()->str, cur_exp_str()->len) ;
-            @<Run a script@>
+            @<Run a script@>@;
             free(s);
         }
     }
 }
 
-@ The |texscriptmode| parameter controls how spaces and newlines get honoured in
-|btex| or |verbatimtex| ... |etex|. The default value is~1. Possible values are:
-0: no newlines, 1: newlines in |verbatimtex|, 2: newlines in |verbatimtex| and
-|etex|, 3: no leading and trailing strip in |verbatimtex|, 4: no leading and
-trailing strip in |verbatimtex| and |btex|. That way the Lua handler can do what
-it likes. An |etex| has to be followed by a space or |;| or be at the end of a
-line and preceded by a space or at the beginning of a line.
+@ The |texscriptmode| parameter controls how spaces and newlines get honored in
+\&{btex} or \&{verbatimtex} ... \&{etex}. The default value is~1. Possible
+values are: 0: no newlines, 1: newlines in \&{verbatimtex}, 2: newlines in
+\&{verbatimtex} and \&{etex}, 3: no leading and trailing strip in
+\&{verbatimtex}, 4: no leading and trailing strip in \&{verbatimtex} and
+\&{btex}.  That way the Lua handler can do what it likes. An \&{etex} has to be
+followed by a space or |;| or be at the end of a line and preceded by a space
+or at the beginning of a line.
 
-@<Pass btex ... etex to script@>=
+@<Pass \&{btex} ... \&{etex} to script@>=
 {
     char *txt = NULL;
     char *ptr = NULL;
@@ -20148,7 +20112,7 @@ line and preceded by a space or at the beginning of a line.
                                         /* we're past the 'x' */
                                         break;
                                     } else {
-                                        /* this is no valid etex */
+                                        /* this is no valid \&{etex} */
                                         done = 0;
                                     }
                                 } else {
@@ -20163,7 +20127,7 @@ line and preceded by a space or at the beginning of a line.
                 }
             }
         }
-        /* no etex seen (yet) */
+        /* no \&{etex} seen (yet) */
         if (loc >= limit) {
             if (size) {
                 txt = realloc(txt, size + limit - first + 1);
@@ -20175,10 +20139,10 @@ line and preceded by a space or at the beginning of a line.
             if (mode <= 0) {
                 txt[size - 1] = ' ';
             } else if (verb) {
-                /* modes $\geq 1$ permit a newline in verbatimtex */
+                /* modes $\geq 1$ permit a newline in \&{verbatimtex} */
                 txt[size - 1] = '\n';
             } else if (mode >= 2) {
-                /* modes $\geq 2$ permit a newline in btex */
+                /* modes $\geq 2$ permit a newline in \&{btex} */
                 txt[size - 1] = '\n';
             } else {
                 txt[size - 1] = ' ';
@@ -20196,12 +20160,12 @@ line and preceded by a space or at the beginning of a line.
         /* we're past the 'x' */
         int l = loc - 5 ; // 4
         int n = l - first + 1 ;
-        /* we're before the 'etex' */
+        /* we're before the \&{etex} */
         if (done == 2) {
-            /* we had ' etex' */
+            /* we had \&{etex} */
             l -= 1;
             n -= 1;
-            /* we're before the ' etex' */
+            /* we're before the \&{etex} */
         }
         if (size) {
             txt = realloc(txt, size + n + 1);
@@ -20211,11 +20175,11 @@ line and preceded by a space or at the beginning of a line.
         (void) memcpy (txt + size, mp->buffer + first, n); /* 0 */
         size += n;
         if (verb && mode >= 3) {
-            /* don't strip verbatimtex */
+            /* don't strip \&{verbatimtex} */
             txt[size] = '\0';
             ptr = txt;
         } else if (mode >= 4) {
-            /* don't strip btex */
+            /* don't strip \&{btex} */
             txt[size] = '\0';
             ptr = txt;
         } else {
@@ -20236,7 +20200,7 @@ line and preceded by a space or at the beginning of a line.
         /* action */
         {
             char *s = mp->make_text(mp,ptr,size,verb) ;
-            @<Run a script@>
+            @<Run a script@>@;
             free(s);
         }
         free(txt);
@@ -20250,7 +20214,7 @@ line and preceded by a space or at the beginning of a line.
     */
     FATAL_ERROR:
     {
-        /* line numbers are not always meaningfull so we can get a 0 reported */
+        /* line numbers are not always meaningful so we can get a 0 reported */
         char msg[256];
         const char *hlp[] = { "An 'etex' is missing at this input level, nothing gets done.", NULL };
         if (slin > 0) {
@@ -20280,14 +20244,14 @@ line and preceded by a space or at the beginning of a line.
         new_number(new_expr.data.n);
         mp_disp_err (mp, NULL);
         mp_back_error (mp, "Not a string", hlp, true);
-        @.Not a string@>;
+        @.Not a string@>
         mp_get_x_next (mp);
         mp_flush_cur_exp (mp, new_expr);
     } else {
         mp_back_input (mp);
         if (cur_exp_str ()->len > 0) {
             char *s = mp->make_text(mp,(const char*) cur_exp_str()->str,cur_exp_str()->len,0) ;
-            @<Run a script@>
+            @<Run a script@>@;
             free(s);
         }
     }
@@ -20397,13 +20361,11 @@ void mp_macro_call (MP mp, mp_node def_ref, mp_node arg_list, mp_sym macro_name)
   add_mac_ref (def_ref);
   if (arg_list == NULL) {
     n = 0;
-  } else {
+  } else
     @<Determine the number |n| of arguments already supplied,
-    and set |tail| to the tail of |arg_list|@>;
-  }
-  if (number_positive (internal_value (mp_tracing_macros))) {
-    @<Show the text of the macro being expanded, and the existing arguments@>;
-  }
+    and set |tail| to the tail of |arg_list|@>@;
+  if (number_positive (internal_value (mp_tracing_macros)))
+    @<Show the text of the macro being expanded, and the existing arguments@>@;
   @<Scan the remaining arguments, if any; set |r| to the first token
     of the replacement text@>;
   @<Feed the arguments and replacement text to the scanner@>;
@@ -20411,24 +20373,25 @@ void mp_macro_call (MP mp, mp_node def_ref, mp_node arg_list, mp_sym macro_name)
 
 
 @ @<Show the text of the macro...@>=
-mp_begin_diagnostic (mp);
-mp_print_ln (mp);
-mp_print_macro_name (mp, arg_list, macro_name);
-if (n == 3)
-  mp_print (mp, "@@#");         /* indicate a suffixed macro */
-mp_show_macro (mp, def_ref, NULL, 100000);
-if (arg_list != NULL) {
-  n = 0;
-  p = arg_list;
-  do {
-    q = (mp_node)mp_sym_sym (p);
-    mp_print_arg (mp, q, n, 0, 0);
-    incr (n);
-    p = mp_link (p);
-  } while (p != NULL);
+{
+  mp_begin_diagnostic (mp);
+  mp_print_ln (mp);
+  mp_print_macro_name (mp, arg_list, macro_name);
+  if (n == 3)
+    mp_print (mp, "@@#");         /* indicate a suffixed macro */
+  mp_show_macro (mp, def_ref, NULL, 100000);
+  if (arg_list != NULL) {
+    n = 0;
+    p = arg_list;
+    do {
+      q = (mp_node)mp_sym_sym (p);
+      mp_print_arg (mp, q, n, 0, 0);
+      incr (n);
+      p = mp_link (p);
+    } while (p != NULL);
+  }
+  mp_end_diagnostic (mp, false);
 }
-mp_end_diagnostic (mp, false)
-
 
 @ @<Declarations@>=
 static void mp_print_macro_name (MP mp, mp_node a, mp_sym n);
@@ -20511,13 +20474,12 @@ if (cur_cmd() == mp_comma) {
   mp_snprintf (msg, 256, "Too many arguments to %s; Missing `%s' has been inserted",
 	       mp_str(mp, rname), mp_str(mp, text(r_delim)));
   delete_str_ref(rname);
-@.Too many arguments...@>;
-@.Missing `)'...@>;
+@.Too many arguments...@>
+@.Missing `)'...@>
   mp_error (mp, msg, hlp, true);
 }
-if (mp_sym_info (r) != mp_general_macro) {
-  @<Scan undelimited argument(s)@>;
-}
+if (mp_sym_info (r) != mp_general_macro)
+  @<Scan undelimited argument(s)@>@;
 r = mp_link (r)
 
 
@@ -20547,10 +20509,10 @@ if (cur_cmd() != mp_comma) {
     sname = mp_make_string(mp);
     mp->selector = old_setting;
     mp_snprintf (msg, 256, "Missing argument to %s", mp_str(mp, sname));
-@.Missing argument...@>;
+@.Missing argument...@>
     delete_str_ref(sname);
     if (mp_name_type (r) == mp_suffix_sym || mp_name_type (r) == mp_text_sym) {
-      set_cur_exp_value_number (zero_t);  /* todo: this was |null| */
+      set_cur_exp_value_number (zero_t);  /* TODO: this was |NULL| */
       mp->cur_exp.type = mp_token_list;
     } else {
       set_cur_exp_value_number (zero_t);
@@ -20565,7 +20527,7 @@ if (cur_cmd() != mp_comma) {
 }
 @<Scan the argument represented by |mp_sym_info(r)|@>;
 if (cur_cmd() != mp_comma)
-  @<Check that the proper right delimiter was present@>;
+  @<Check that the proper right delimiter was present@>@;
 FOUND:
 @<Append the current expression to |arg_list|@>
 
@@ -20581,7 +20543,7 @@ if ((cur_cmd() != mp_right_delimiter) || (equiv_sym (cur_sym()) != l_delim)) {
            "You might want to delete some tokens before continuing.",
            NULL };
     mp_back_error (mp, "Missing `,' has been inserted", hlp, true);
-@.Missing `,'@>;
+@.Missing `,'@>
     set_cur_cmd((mp_variable_type)mp_comma);
   } else {
     char msg[256];
@@ -20590,7 +20552,7 @@ if ((cur_cmd() != mp_right_delimiter) || (equiv_sym (cur_sym()) != l_delim)) {
            "You might want to delete some tokens before continuing.",
            NULL };
     mp_snprintf(msg, 256, "Missing `%s' has been inserted", mp_str(mp, text(r_delim)));
-@.Missing `)'@>;
+@.Missing `)'@>
     mp_back_error (mp, msg, hlp, true);
   }
 }
@@ -20652,11 +20614,10 @@ void mp_scan_text_arg (MP mp, mp_sym l_delim, mp_sym r_delim) {
   mp_link (mp->hold_head) = NULL;
   while (1) {
     get_t_next (mp);
-    if (l_delim == NULL) {
-      @<Adjust the balance for an undelimited argument; |break| if done@>;
-    } else {
-      @<Adjust the balance for a delimited argument; |break| if done@>;
-    }
+    if (l_delim == NULL)
+      @<Adjust the balance for an undelimited argument; |break| if done@>@;
+    else
+      @<Adjust the balance for a delimited argument; |break| if done@>@;
     mp_link (p) = mp_cur_tok (mp);
     p = mp_link (p);
   }
@@ -20667,27 +20628,31 @@ void mp_scan_text_arg (MP mp, mp_sym l_delim, mp_sym r_delim) {
 
 
 @ @<Adjust the balance for a delimited argument...@>=
-if (cur_cmd() == mp_right_delimiter) {
-  if (equiv_sym (cur_sym()) == l_delim) {
-    decr (balance);
-    if (balance == 0)
-      break;
+{
+  if (cur_cmd() == mp_right_delimiter) {
+    if (equiv_sym (cur_sym()) == l_delim) {
+      decr (balance);
+      if (balance == 0)
+        break;
+    }
+  } else if (cur_cmd() == mp_left_delimiter) {
+    if (equiv_sym (cur_sym()) == r_delim)
+      incr (balance);
   }
-} else if (cur_cmd() == mp_left_delimiter) {
-  if (equiv_sym (cur_sym()) == r_delim)
-    incr (balance);
 }
 
 @ @<Adjust the balance for an undelimited...@>=
-if (mp_end_of_statement) {         /* |cur_cmd=semicolon|, |end_group|, or |stop| */
-  if (balance == 1) {
-    break;
-  } else {
-    if (cur_cmd() == mp_end_group)
-      decr (balance);
+{
+  if (mp_end_of_statement) {         /* |cur_cmd=semicolon|, |end_group|, or |stop| */
+    if (balance == 1) {
+      break;
+    } else {
+      if (cur_cmd() == mp_end_group)
+        decr (balance);
+    }
+  } else if (cur_cmd() == mp_begin_group) {
+    incr (balance);
   }
-} else if (cur_cmd() == mp_begin_group) {
-  incr (balance);
 }
 
 @ @<Scan undelimited argument(s)@>=
@@ -20756,7 +20721,7 @@ if (mp_end_of_statement) {         /* |cur_cmd=semicolon|, |end_group|, or |stop
     mp->selector = old_setting;
     mp_snprintf (msg, 256, "Missing `of' has been inserted for %s", mp_str(mp, sname));
     delete_str_ref(sname);
-@.Missing `of'@>;
+@.Missing `of'@>
     mp_back_error (mp, msg, hlp, true);
   }
   mp_get_x_next (mp);
@@ -20782,7 +20747,7 @@ if (mp_end_of_statement) {         /* |cur_cmd=semicolon|, |end_group|, or |stop
         "You might want to delete some tokens before continuing.",
         NULL };
       mp_snprintf(msg, 256, "Missing `%s' has been inserted", mp_str (mp, text (r_delim)));
-@.Missing `)'@>;
+@.Missing `)'@>
       mp_back_error (mp, msg, hlp, true);
     }
     mp_get_x_next (mp);
@@ -20858,13 +20823,12 @@ corresponding |if_line|.
 
 @<MPlib internal header stuff@>=
 typedef struct mp_if_node_data {
-  NODE_BODY;
+  NODE_BODY;@+@t}\6{@>
   int if_line_field_;
 } mp_if_node_data;
 typedef struct mp_if_node_data *mp_if_node;
 
-@
-@d if_node_size sizeof(struct mp_if_node_data) /* number of words in stack entry for conditionals */
+@ @d if_node_size sizeof(struct mp_if_node_data) /* number of words in stack entry for conditionals */
 
 @c
 static mp_node mp_get_if_node (MP mp) {
@@ -20888,12 +20852,12 @@ mp->if_line = 0;
 
 @ @<Put each...@>=
 mp_primitive (mp, "if", mp_if_test, if_code);
-@:if_}{\&{if} primitive@>;
+@:if_}{\&{if} primitive@>
 mp_primitive (mp, "fi", mp_fi_or_else, fi_code);
 mp->frozen_fi = mp_frozen_primitive (mp, "fi", mp_fi_or_else, fi_code);
-@:fi_}{\&{fi} primitive@>;
+@:fi_}{\&{fi} primitive@>
 mp_primitive (mp, "else", mp_fi_or_else, else_code);
-@:else_}{\&{else} primitive@>;
+@:else_}{\&{else} primitive@>
 mp_primitive (mp, "elseif", mp_fi_or_else, else_if_code);
 @:else_if_}{\&{elseif} primitive@>
 
@@ -20941,10 +20905,9 @@ void mp_pass_text (MP mp) {
         if (cur_mod() == fi_code)
           decr (l);
       }
-    } else {
+    } else
       @<Decrease the string reference count,
-       if the current token is a string@>;
-    }
+       if the current token is a string@>@;
   }
   mp->scanner_status = normal;
 }
@@ -20998,7 +20961,7 @@ static void mp_change_if_limit (MP mp, quarterword l, mp_node p) {
     while (1) {
       if (q == NULL)
         mp_confusion (mp, "if");
-@:this can't happen if}{\quad if@>;
+@:this can't happen if}{\quad if@>
       /* clang: dereference of null pointer */ assert(q);
       if (mp_link (q) == p) {
         mp_type (q) = l;
@@ -21021,7 +20984,7 @@ static void mp_check_colon (MP mp) {
            "I shall pretend that one was there.",
            NULL };
     mp_back_error (mp, "Missing `:' has been inserted", hlp, true);
-@.Missing `:'@>;
+@.Missing `:'@>
   }
 }
 
@@ -21049,7 +21012,7 @@ FOUND:
   if (cur_exp_value_boolean () == mp_true_code) {
     mp_change_if_limit (mp, (quarterword) new_if_limit, save_cond_ptr);
     return;                     /* wait for \&{elseif}, \&{else}, or \&{fi} */
-  };
+  }
   @<Skip to \&{elseif} or \&{else} or \&{fi}, then |goto done|@>;
 DONE:
   mp->cur_if = (quarterword) cur_mod();
@@ -21104,12 +21067,12 @@ if (cur_mod() > mp->if_limit) {
     mp_back_input (mp);
     set_cur_sym(mp->frozen_colon);
     mp_ins_error (mp, "Missing `:' has been inserted", hlp, true);
-@.Missing `:'@>;
+@.Missing `:'@>
   } else {
     const char *hlp[] =  {"I'm ignoring this; it doesn't match any if.", NULL};
     if (cur_mod() == fi_code) {
        mp_error(mp, "Extra fi", hlp, true);
-@.Extra fi@>;
+@.Extra fi@>
     } else if (cur_mod() == else_code) {
        mp_error(mp, "Extra else", hlp, true);
 @.Extra else@>
@@ -21165,7 +21128,7 @@ typedef struct mp_loop_data {
   mp_node type; /* the special type of this loop, or a pointer into
                    mem */
   mp_node list; /* the remaining list elements */
-  mp_node list_start;   /* head fo the list of elements */
+  mp_node list_start;   /* head of the list of elements */
   mp_number old_value; /* previous value of current arithmetic value */
   mp_number value; /* current arithmetic value */
   mp_number step_size;     /* arithmetic step size */
@@ -21197,7 +21160,7 @@ static void mp_bad_for (MP mp, const char *s) {
   mp_disp_err (mp, NULL);
   /* show the bad expression above the message */
   mp_snprintf(msg, 256, "Improper %s has been replaced by 0", s);
-@.Improper...replaced by 0@>;
+@.Improper...replaced by 0@>
   mp_back_error (mp, msg, hlp, true);
   mp_get_x_next (mp);
   mp_flush_cur_exp (mp, new_expr);
@@ -21246,9 +21209,9 @@ void mp_begin_iteration (MP mp) {
       p->value_mod = mp_suffix_sym;
     }
     mp_get_x_next (mp);
-    if (p->value_mod == mp_expr_sym && cur_cmd() == mp_within_token) {
-      @<Set up a picture iteration@>;
-    } else {
+    if (p->value_mod == mp_expr_sym && cur_cmd() == mp_within_token)
+      @<Set up a picture iteration@>@;
+    else {
       @<Check for the assignment in a loop header@>;
       @<Scan the values to be used in the loop@>;
     }
@@ -21267,7 +21230,7 @@ if ((cur_cmd() != mp_equals) && (cur_cmd() != mp_assignment)) {
          "was present, and I'll look for the values next.",
          NULL };
   mp_back_error (mp, "Missing `=' has been inserted", hlp, true);
-@.Missing `='@>;
+@.Missing `='@>
 }
 
 @ @<Check for the presence of a colon@>=
@@ -21278,7 +21241,7 @@ if (cur_cmd() != mp_colon) {
          "everything from here to `endfor' will be iterated.",
          NULL };
   mp_back_error (mp, "Missing `:' has been inserted", hlp, true);
-@.Missing `:'@>;
+@.Missing `:'@>
 }
 
 @ We append a special |mp->frozen_repeat_loop| token in place of the
@@ -21299,7 +21262,7 @@ mp->warning_info = n;
 s->info = mp_scan_toks (mp, mp_iteration, p, q, 0);
 mp->scanner_status = normal;
 s->link = mp->loop_ptr;
-mp->loop_ptr = s
+mp->loop_ptr = s@;
 
 @ @<Initialize table...@>=
 mp->frozen_repeat_loop =
@@ -21363,10 +21326,9 @@ void mp_resume_iteration (MP mp) {
   } else if (p == MP_VOID) {
     mp_begin_token_list (mp, mp->loop_ptr->info, (quarterword) forever_text);
     return;
-  } else {
+  } else
     @<Make |q| a capsule containing the next picture component from
-      |loop_list(loop_ptr)| or |goto not_found|@>;
-  }
+      |loop_list(loop_ptr)| or |goto not_found|@>@;
   mp_begin_token_list (mp, mp->loop_ptr->info, (quarterword) loop_text);
   mp_stack_argument (mp, q);
   if (number_greater (internal_value (mp_tracing_commands), unity_t)) {
@@ -21388,7 +21350,7 @@ NOT_FOUND:
 {
   mp_begin_diagnostic (mp);
   mp_print_nl (mp, "{loop value=");
-@.loop value=n@>;
+@.loop value=n@>
   if ((q != NULL) && (mp_link (q) == MP_VOID))
     mp_print_exp (mp, q, 1);
   else
@@ -21497,7 +21459,7 @@ do {
   mp->cur_exp.type = mp_vacuous;
 CONTINUE:
   ;
-} while (cur_cmd() == mp_comma)
+} while (cur_cmd() == mp_comma)@;
 
 @ @<Prepare for step-until construction and |break|@>=
 {
@@ -21516,7 +21478,7 @@ CONTINUE:
            "So I'll look for the final value and colon next.",
            NULL };
     mp_back_error (mp, "Missing `until' has been inserted", hlp, true);
-@.Missing `until'@>;
+@.Missing `until'@>
   }
   mp_get_x_next (mp);
   mp_scan_expression (mp);
@@ -21653,7 +21615,7 @@ of the occurrences of area and extension delimiters.
 integer area_delimiter;
   /* most recent `\.>' or `\.:' relative to |str_start[str_ptr]| */
 integer ext_delimiter;  /* the relevant `\..', if any */
-boolean quoted_filename;        /* whether the filename is wrapped in " markers */
+boolean quoted_filename;        /* whether the filename is wrapped in `\."' markers */
 
 @ Here now is the first of the system-dependent routines for file name scanning.
 @^system dependencies@>
@@ -21711,7 +21673,7 @@ boolean mp_more_name (MP mp, ASCII_code c) {
 void mp_end_name (MP mp) {
   size_t s = 0; /* length of area, name, and extension */
   size_t len;
-  /* "my/w.mp" */
+  /* \.{"my/w.mp"} */
   if (mp->area_delimiter < 0) {
     mp->cur_area = xstrdup ("");
   } else {
@@ -21873,7 +21835,7 @@ boolean mp_open_mem_file (MP mp) {
     wterm (mp->mem_name);
     wterm ("' preload file; will try 'plain'.");
     wterm_cr;
-@.Sorry, I can't find...@>;
+@.Sorry, I can't find...@>
     update_terminal();
     /* now pull out all the stops: try for the system \.{plain} file */
     xfree (mp->mem_name);
@@ -21884,7 +21846,7 @@ boolean mp_open_mem_file (MP mp) {
   wake_up_terminal();
   wterm_ln ("I can't find the 'plain' preload file!\n");
 @.I can't find PLAIN...@>
-@.plain@>;
+@.plain@>
   return false;
 }
 
@@ -21896,7 +21858,7 @@ ideally be changed to deduce the full name of file~|f|, which is the file
 most recently opened, if it is possible to do this.
 @^system dependencies@>
 
-@ @c
+@c
 static mp_string mp_make_name_string (MP mp) {
   int k;        /* index into |name_of_file| */
   int name_length = (int) strlen (mp->name_of_file);
@@ -22017,7 +21979,7 @@ if (opt->noninteractive) {
 }
 mp->log_opened = false;
 
-@ Cannot do this earlier because at the |<Allocate or ...>|, the string
+@ Cannot do this earlier because at the |@<Allocate or ...@>| block, the string
 pool is not yet initialized.
 
 @<Fix up |mp->internal[mp_job_name]|@>=
@@ -22084,10 +22046,10 @@ void mp_prompt_file_name (MP mp, const char *s, const char *e) {
     mp_show_context (mp);
   mp_print_nl (mp, "Please type another ");
   mp_print (mp, s);
-@.Please type...@>;
+@.Please type...@>
   if (mp->noninteractive || mp->interaction < mp_scroll_mode)
     mp_fatal_error (mp, "*** (job aborted, file error in nonstop mode)");
-@.job aborted, file error...@>;
+@.job aborted, file error...@>
   saved_cur_name = xstrdup (mp->cur_name);
   clear_terminal();
   prompt_input (": ");
@@ -22139,9 +22101,8 @@ void mp_open_log_file (MP mp) {
     @<Fix up |mp->internal[mp_job_name]|@>;
   }
   mp_pack_job_name (mp, ".log");
-  while (!mp_open_out (mp, &mp->log_file, mp_filetype_log)) {
-    @<Try to get a different log file name@>;
-  }
+  while (!mp_open_out (mp, &mp->log_file, mp_filetype_log))
+    @<Try to get a different log file name@>@;
   mp->log_name = xstrdup (mp->name_of_file);
   mp->selector = log_only;
   mp->log_opened = true;
@@ -22150,7 +22111,7 @@ void mp_open_log_file (MP mp) {
   /* make sure bottom level is in memory */
   if (!mp->noninteractive) {
     mp_print_nl (mp, "**");
-@.**@>;
+@.**@>
     l = mp->input_stack[0].limit_field - 1;     /* last position of first line */
     for (k = 0; k <= l; k++)
       mp_print_char (mp, mp->buffer[k]);
@@ -22276,7 +22237,7 @@ than just a copy of its argument and the full file name is needed for opening
 @<Flush |name| and replace it with |cur_name| if it won't be needed@>=
 mp_flush_string (mp, name);
 name = mp_rts (mp, mp->cur_name);
-xfree (mp->cur_name)
+xfree (mp->cur_name)@;
 
 
 @ If the file is empty, it is considered to contain a single blank line,
@@ -22303,7 +22264,7 @@ if (token_state) {
          "Please delete the tokens and insert the name again.",
          NULL };
   mp_error (mp, "File names can't appear within macros", hlp, true);
-@.File names can't...@>;
+@.File names can't...@>
 }
 if (file_state) {
   mp_scan_file_name (mp);
@@ -22354,7 +22315,7 @@ available to perform the function of \.{DVItoMP}.)
 @^system dependencies@>
 
 @ @<Exported types@>=
-typedef int (*mp_makempx_cmd) (MP mp, char *origname, char *mtxname);
+typedef int @[@] (*mp_makempx_cmd) (MP mp, char *origname, char *mtxname);
 
 @ @<Option variables@>=
 mp_makempx_cmd run_make_mpx;
@@ -22501,7 +22462,7 @@ recovery.
     cur_exp_node() = NULL;
     cur_exp_str() = NULL;
     cur_exp_knot() = NULL;
-  } while (0)
+  } while (0)@;
 @d set_cur_exp_value_boolean(A) do {
     if (cur_exp_str()) {
         delete_str_ref(cur_exp_str());
@@ -22510,7 +22471,7 @@ recovery.
     cur_exp_node() = NULL;
     cur_exp_str() = NULL;
     cur_exp_knot() = NULL;
-  } while (0)
+  } while (0)@;
 @d set_cur_exp_value_number(A) do {
     if (cur_exp_str()) {
         delete_str_ref(cur_exp_str());
@@ -22519,7 +22480,7 @@ recovery.
     cur_exp_node() = NULL;
     cur_exp_str() = NULL;
     cur_exp_knot() = NULL;
-  } while (0)
+  } while (0)@;
 @d set_cur_exp_node(A) do {
     if (cur_exp_str()) {
         delete_str_ref(cur_exp_str());
@@ -22528,7 +22489,7 @@ recovery.
     cur_exp_str() = NULL;
     cur_exp_knot() = NULL;
     set_number_to_zero (mp->cur_exp.data.n);
-  } while (0)
+  } while (0)@;
 @d set_cur_exp_str(A) do {
     if (cur_exp_str()) {
         delete_str_ref(cur_exp_str());
@@ -22538,7 +22499,7 @@ recovery.
     cur_exp_node() = NULL;
     cur_exp_knot() = NULL;
     set_number_to_zero (mp->cur_exp.data.n);
-  } while (0)
+  } while (0)@;
 @d set_cur_exp_knot(A) do {
     if (cur_exp_str()) {
         delete_str_ref(cur_exp_str());
@@ -22547,7 +22508,7 @@ recovery.
     cur_exp_node() = NULL;
     cur_exp_str() = NULL;
     set_number_to_zero (mp->cur_exp.data.n);
-  } while (0)
+  } while (0)@;
 
 
 @ @<Glob...@>=
@@ -23032,7 +22993,7 @@ if (verbosity <= 1) {
       mp_print_type (mp, t);
       mp_print (mp, " (see the transcript file)");
       mp->selector = term_and_log;
-    };
+    }
   switch (t) {
   case mp_pen_type:
     mp_print_pen (mp, value_knot (p), "", false);
@@ -23072,7 +23033,7 @@ the ring consists entirely of capsules.
     while ((mp_name_type (v) == mp_capsule) && (v != p))
       v = value_node (v);
     mp_print_variable_name (mp, v);
-  };
+  }
 }
 
 
@@ -23088,7 +23049,7 @@ void mp_disp_err (MP mp, mp_node p) {
   if (mp->interaction == mp_error_stop_mode)
     wake_up_terminal();
   mp_print_nl (mp, ">> ");
-@.>>@>;
+@.>>@>
   mp_print_exp (mp, p, 1);      /* ``medium verbose'' printing of the expression */
 }
 
@@ -23099,7 +23060,7 @@ to |known| and stores a given value in |cur_exp|. We can think of |cur_type|
 and |cur_exp| as either alive or dormant after this has been done,
 because |cur_exp| will not contain a pointer value.
 
-@ @c
+@c
 void mp_flush_cur_exp (MP mp, mp_value v) {
   if (is_number(mp->cur_exp.data.n)) {
     free_number(mp->cur_exp.data.n);
@@ -23991,7 +23952,7 @@ static void mp_bad_exp (MP mp, const char *s) {
          "delete this zero and insert something else;",
          "see Chapter 27 of The METAFONTbook for an example.",
          NULL };
-@:METAFONTbook}{\sl The {\logos METAFONT\/}book@>;
+@:METAFONTbook}{\sl The {\logos METAFONT\/}book@>
   {
      mp_string cm;
      int old_selector = mp->selector;
@@ -24071,7 +24032,7 @@ relation |tt=mp_type(q)| will always hold. If |tt=undefined|, the routine
 doesn't bother to update its information about type. And if
 |undefined<tt<mp_unsuffixed_macro|, the precise value of |tt| isn't critical.
 
-@ @<Scan a variable primary...@>=
+@<Scan a variable primary...@>=
 {
   mp_node p, q;      /* for list manipulation */
   mp_node t;      /* a token */
@@ -24255,7 +24216,7 @@ static void mp_bad_subscript (MP mp) {
   new_number(new_expr.data.n);
   mp_disp_err(mp, NULL);
   mp_error (mp, "Improper subscript has been replaced by zero", hlp, true);
-@.Improper subscript...@>;
+@.Improper subscript...@>
   mp_flush_cur_exp (mp, new_expr);
 }
 
@@ -24287,7 +24248,7 @@ static char *mp_obliterated (MP mp, mp_node q) {
   sname = mp_make_string(mp);
   mp->selector = old_setting;
   mp_snprintf(msg, 256, "Variable %s has been obliterated", mp_str(mp, sname));
-@.Variable...obliterated@>;
+@.Variable...obliterated@>
   delete_str_ref(sname);
   return xstrdup(msg);
 }
@@ -24414,7 +24375,7 @@ RESTART:
     break;
   default:
     mp_confusion (mp, "copy");
-@:this can't happen copy}{\quad copy@>;
+@:this can't happen copy}{\quad copy@>
     break;
   }
 }
@@ -24530,7 +24491,7 @@ RESTART:
   if ((cur_cmd() < mp_min_primary_command) ||
       (cur_cmd() > mp_max_primary_command))
     mp_bad_exp (mp, "A secondary");
-@.A secondary expression...@>;
+@.A secondary expression...@>
   mp_scan_primary (mp);
 CONTINUE:
   if (cur_cmd() <= mp_max_secondary_command &&
@@ -24586,7 +24547,7 @@ RESTART:
   if ((cur_cmd() < mp_min_primary_command) ||
       (cur_cmd() > mp_max_primary_command))
     mp_bad_exp (mp, "A tertiary");
-@.A tertiary expression...@>;
+@.A tertiary expression...@>
   mp_scan_secondary (mp);
 CONTINUE:
   if (cur_cmd() <= mp_max_tertiary_command) {
@@ -24630,7 +24591,7 @@ RESTART:
   if ((cur_cmd() < mp_min_primary_command) ||
       (cur_cmd() > mp_max_primary_command))
     mp_bad_exp (mp, "An");
-@.An expression...@>;
+@.An expression...@>
   mp_scan_tertiary (mp);
 CONTINUE:
   if (cur_cmd() <= mp_max_expression_command) {
@@ -24810,7 +24771,7 @@ CONTINUE_PATH:
       set_number_to_unity(y);
       mp_back_input (mp);         /* default tension */
       goto DONE;
-    };
+    }
     if (cur_cmd() != mp_path_join) {
       const char *hlp[] = { "A path join command should end with two dots.", NULL};
       mp_back_error (mp, "Missing `..' has been inserted", hlp, true);
@@ -24884,7 +24845,7 @@ CONTINUE_PATH:
              "So I'm going to pretend that you said `p..q' instead.",
              NULL };
       mp_back_error (mp, "Paths don't touch; `&' will be changed to `..'", hlp, true);
-@.Paths don't touch@>;
+@.Paths don't touch@>
       mp_get_x_next (mp);
       d = mp_path_join;
       set_number_to_unity (path_q->right_tension);
@@ -24932,7 +24893,7 @@ CONTINUE_PATH:
     if (t != mp_open) {
       number_clone (pp->left_x, x);
       mp_left_type (pp) = (unsigned short) t;
-    };
+    }
   }
   path_q = qq;
 
@@ -25176,7 +25137,7 @@ supposed to be either |true_code| or |false_code|.
   if (mp->cur_exp.type != mp_boolean_type) {
     do_boolean_error(mp);
   }
-} while (0)
+} while (0)@;
 
 @<Declare the basic parsing subroutines@>=
 static void do_boolean_error (MP mp) {
@@ -25218,218 +25179,218 @@ operation it performs is a |primary_binary| or |secondary_binary|, etc.
 
 @<Put each...@>=
 mp_primitive (mp, "true", mp_nullary, mp_true_code);
-@:true_}{\&{true} primitive@>;
+@:true_}{\&{true} primitive@>
 mp_primitive (mp, "false", mp_nullary, mp_false_code);
-@:false_}{\&{false} primitive@>;
+@:false_}{\&{false} primitive@>
 mp_primitive (mp, "nullpicture", mp_nullary, mp_null_picture_code);
-@:null_picture_}{\&{nullpicture} primitive@>;
+@:null_picture_}{\&{nullpicture} primitive@>
 mp_primitive (mp, "nullpen", mp_nullary, mp_null_pen_code);
-@:null_pen_}{\&{nullpen} primitive@>;
+@:null_pen_}{\&{nullpen} primitive@>
 mp_primitive (mp, "readstring", mp_nullary, mp_read_string_op);
-@:read_string_}{\&{readstring} primitive@>;
+@:read_string_}{\&{readstring} primitive@>
 mp_primitive (mp, "pencircle", mp_nullary, mp_pen_circle);
-@:pen_circle_}{\&{pencircle} primitive@>;
+@:pen_circle_}{\&{pencircle} primitive@>
 mp_primitive (mp, "normaldeviate", mp_nullary, mp_normal_deviate);
-@:normal_deviate_}{\&{normaldeviate} primitive@>;
+@:normal_deviate_}{\&{normaldeviate} primitive@>
 mp_primitive (mp, "readfrom", mp_unary, mp_read_from_op);
-@:read_from_}{\&{readfrom} primitive@>;
+@:read_from_}{\&{readfrom} primitive@>
 mp_primitive (mp, "closefrom", mp_unary, mp_close_from_op);
-@:close_from_}{\&{closefrom} primitive@>;
+@:close_from_}{\&{closefrom} primitive@>
 mp_primitive (mp, "odd", mp_unary, mp_odd_op);
-@:odd_}{\&{odd} primitive@>;
+@:odd_}{\&{odd} primitive@>
 mp_primitive (mp, "known", mp_unary, mp_known_op);
-@:known_}{\&{known} primitive@>;
+@:known_}{\&{known} primitive@>
 mp_primitive (mp, "unknown", mp_unary, mp_unknown_op);
-@:unknown_}{\&{unknown} primitive@>;
+@:unknown_}{\&{unknown} primitive@>
 mp_primitive (mp, "not", mp_unary, mp_not_op);
-@:not_}{\&{not} primitive@>;
+@:not_}{\&{not} primitive@>
 mp_primitive (mp, "decimal", mp_unary, mp_decimal);
-@:decimal_}{\&{decimal} primitive@>;
+@:decimal_}{\&{decimal} primitive@>
 mp_primitive (mp, "reverse", mp_unary, mp_reverse);
-@:reverse_}{\&{reverse} primitive@>;
+@:reverse_}{\&{reverse} primitive@>
 mp_primitive (mp, "makepath", mp_unary, mp_make_path_op);
-@:make_path_}{\&{makepath} primitive@>;
+@:make_path_}{\&{makepath} primitive@>
 mp_primitive (mp, "makepen", mp_unary, mp_make_pen_op);
-@:make_pen_}{\&{makepen} primitive@>;
+@:make_pen_}{\&{makepen} primitive@>
 mp_primitive (mp, "oct", mp_unary, mp_oct_op);
-@:oct_}{\&{oct} primitive@>;
+@:oct_}{\&{oct} primitive@>
 mp_primitive (mp, "hex", mp_unary, mp_hex_op);
-@:hex_}{\&{hex} primitive@>;
+@:hex_}{\&{hex} primitive@>
 mp_primitive (mp, "ASCII", mp_unary, mp_ASCII_op);
-@:ASCII_}{\&{ASCII} primitive@>;
+@:ASCII_}{\&{ASCII} primitive@>
 mp_primitive (mp, "char", mp_unary, mp_char_op);
-@:char_}{\&{char} primitive@>;
+@:char_}{\&{char} primitive@>
 mp_primitive (mp, "length", mp_unary, mp_length_op);
-@:length_}{\&{length} primitive@>;
+@:length_}{\&{length} primitive@>
 mp_primitive (mp, "turningnumber", mp_unary, mp_turning_op);
-@:turning_number_}{\&{turningnumber} primitive@>;
+@:turning_number_}{\&{turningnumber} primitive@>
 mp_primitive (mp, "xpart", mp_unary, mp_x_part);
-@:x_part_}{\&{xpart} primitive@>;
+@:x_part_}{\&{xpart} primitive@>
 mp_primitive (mp, "ypart", mp_unary, mp_y_part);
-@:y_part_}{\&{ypart} primitive@>;
+@:y_part_}{\&{ypart} primitive@>
 mp_primitive (mp, "xxpart", mp_unary, mp_xx_part);
-@:xx_part_}{\&{xxpart} primitive@>;
+@:xx_part_}{\&{xxpart} primitive@>
 mp_primitive (mp, "xypart", mp_unary, mp_xy_part);
-@:xy_part_}{\&{xypart} primitive@>;
+@:xy_part_}{\&{xypart} primitive@>
 mp_primitive (mp, "yxpart", mp_unary, mp_yx_part);
-@:yx_part_}{\&{yxpart} primitive@>;
+@:yx_part_}{\&{yxpart} primitive@>
 mp_primitive (mp, "yypart", mp_unary, mp_yy_part);
-@:yy_part_}{\&{yypart} primitive@>;
+@:yy_part_}{\&{yypart} primitive@>
 mp_primitive (mp, "redpart", mp_unary, mp_red_part);
-@:red_part_}{\&{redpart} primitive@>;
+@:red_part_}{\&{redpart} primitive@>
 mp_primitive (mp, "greenpart", mp_unary, mp_green_part);
-@:green_part_}{\&{greenpart} primitive@>;
+@:green_part_}{\&{greenpart} primitive@>
 mp_primitive (mp, "bluepart", mp_unary, mp_blue_part);
-@:blue_part_}{\&{bluepart} primitive@>;
+@:blue_part_}{\&{bluepart} primitive@>
 mp_primitive (mp, "cyanpart", mp_unary, mp_cyan_part);
-@:cyan_part_}{\&{cyanpart} primitive@>;
+@:cyan_part_}{\&{cyanpart} primitive@>
 mp_primitive (mp, "magentapart", mp_unary, mp_magenta_part);
-@:magenta_part_}{\&{magentapart} primitive@>;
+@:magenta_part_}{\&{magentapart} primitive@>
 mp_primitive (mp, "yellowpart", mp_unary, mp_yellow_part);
-@:yellow_part_}{\&{yellowpart} primitive@>;
+@:yellow_part_}{\&{yellowpart} primitive@>
 mp_primitive (mp, "blackpart", mp_unary, mp_black_part);
-@:black_part_}{\&{blackpart} primitive@>;
+@:black_part_}{\&{blackpart} primitive@>
 mp_primitive (mp, "greypart", mp_unary, mp_grey_part);
-@:grey_part_}{\&{greypart} primitive@>;
+@:grey_part_}{\&{greypart} primitive@>
 mp_primitive (mp, "colormodel", mp_unary, mp_color_model_part);
-@:color_model_part_}{\&{colormodel} primitive@>;
+@:color_model_part_}{\&{colormodel} primitive@>
 mp_primitive (mp, "fontpart", mp_unary, mp_font_part);
-@:font_part_}{\&{fontpart} primitive@>;
+@:font_part_}{\&{fontpart} primitive@>
 mp_primitive (mp, "textpart", mp_unary, mp_text_part);
-@:text_part_}{\&{textpart} primitive@>;
+@:text_part_}{\&{textpart} primitive@>
 mp_primitive (mp, "prescriptpart", mp_unary, mp_prescript_part);
-@:prescript_part_}{\&{prescriptpart} primitive@>;
+@:prescript_part_}{\&{prescriptpart} primitive@>
 mp_primitive (mp, "postscriptpart", mp_unary, mp_postscript_part);
-@:postscript_part_}{\&{postscriptpart} primitive@>;
+@:postscript_part_}{\&{postscriptpart} primitive@>
 mp_primitive (mp, "pathpart", mp_unary, mp_path_part);
-@:path_part_}{\&{pathpart} primitive@>;
+@:path_part_}{\&{pathpart} primitive@>
 mp_primitive (mp, "penpart", mp_unary, mp_pen_part);
-@:pen_part_}{\&{penpart} primitive@>;
+@:pen_part_}{\&{penpart} primitive@>
 mp_primitive (mp, "dashpart", mp_unary, mp_dash_part);
-@:dash_part_}{\&{dashpart} primitive@>;
+@:dash_part_}{\&{dashpart} primitive@>
 mp_primitive (mp, "sqrt", mp_unary, mp_sqrt_op);
-@:sqrt_}{\&{sqrt} primitive@>;
+@:sqrt_}{\&{sqrt} primitive@>
 mp_primitive (mp, "mexp", mp_unary, mp_m_exp_op);
-@:m_exp_}{\&{mexp} primitive@>;
+@:m_exp_}{\&{mexp} primitive@>
 mp_primitive (mp, "mlog", mp_unary, mp_m_log_op);
-@:m_log_}{\&{mlog} primitive@>;
+@:m_log_}{\&{mlog} primitive@>
 mp_primitive (mp, "sind", mp_unary, mp_sin_d_op);
-@:sin_d_}{\&{sind} primitive@>;
+@:sin_d_}{\&{sind} primitive@>
 mp_primitive (mp, "cosd", mp_unary, mp_cos_d_op);
-@:cos_d_}{\&{cosd} primitive@>;
+@:cos_d_}{\&{cosd} primitive@>
 mp_primitive (mp, "floor", mp_unary, mp_floor_op);
-@:floor_}{\&{floor} primitive@>;
+@:floor_}{\&{floor} primitive@>
 mp_primitive (mp, "uniformdeviate", mp_unary, mp_uniform_deviate);
-@:uniform_deviate_}{\&{uniformdeviate} primitive@>;
+@:uniform_deviate_}{\&{uniformdeviate} primitive@>
 mp_primitive (mp, "charexists", mp_unary, mp_char_exists_op);
-@:char_exists_}{\&{charexists} primitive@>;
+@:char_exists_}{\&{charexists} primitive@>
 mp_primitive (mp, "fontsize", mp_unary, mp_font_size);
-@:font_size_}{\&{fontsize} primitive@>;
+@:font_size_}{\&{fontsize} primitive@>
 mp_primitive (mp, "llcorner", mp_unary, mp_ll_corner_op);
-@:ll_corner_}{\&{llcorner} primitive@>;
+@:ll_corner_}{\&{llcorner} primitive@>
 mp_primitive (mp, "lrcorner", mp_unary, mp_lr_corner_op);
-@:lr_corner_}{\&{lrcorner} primitive@>;
+@:lr_corner_}{\&{lrcorner} primitive@>
 mp_primitive (mp, "ulcorner", mp_unary, mp_ul_corner_op);
-@:ul_corner_}{\&{ulcorner} primitive@>;
+@:ul_corner_}{\&{ulcorner} primitive@>
 mp_primitive (mp, "urcorner", mp_unary, mp_ur_corner_op);
-@:ur_corner_}{\&{urcorner} primitive@>;
+@:ur_corner_}{\&{urcorner} primitive@>
 mp_primitive (mp, "arclength", mp_unary, mp_arc_length);
-@:arc_length_}{\&{arclength} primitive@>;
+@:arc_length_}{\&{arclength} primitive@>
 mp_primitive (mp, "angle", mp_unary, mp_angle_op);
-@:angle_}{\&{angle} primitive@>;
+@:angle_}{\&{angle} primitive@>
 mp_primitive (mp, "cycle", mp_cycle, mp_cycle_op);
-@:cycle_}{\&{cycle} primitive@>;
+@:cycle_}{\&{cycle} primitive@>
 mp_primitive (mp, "stroked", mp_unary, mp_stroked_op);
-@:stroked_}{\&{stroked} primitive@>;
+@:stroked_}{\&{stroked} primitive@>
 mp_primitive (mp, "filled", mp_unary, mp_filled_op);
-@:filled_}{\&{filled} primitive@>;
+@:filled_}{\&{filled} primitive@>
 mp_primitive (mp, "textual", mp_unary, mp_textual_op);
-@:textual_}{\&{textual} primitive@>;
+@:textual_}{\&{textual} primitive@>
 mp_primitive (mp, "clipped", mp_unary, mp_clipped_op);
-@:clipped_}{\&{clipped} primitive@>;
+@:clipped_}{\&{clipped} primitive@>
 mp_primitive (mp, "bounded", mp_unary, mp_bounded_op);
-@:bounded_}{\&{bounded} primitive@>;
+@:bounded_}{\&{bounded} primitive@>
 mp_primitive (mp, "+", mp_plus_or_minus, mp_plus);
-@:+ }{\.{+} primitive@>;
+@:+ }{\.{+} primitive@>
 mp_primitive (mp, "-", mp_plus_or_minus, mp_minus);
-@:- }{\.{-} primitive@>;
+@:- }{\.{-} primitive@>
 mp_primitive (mp, "*", mp_secondary_binary, mp_times);
-@:* }{\.{*} primitive@>;
+@:* }{\.{*} primitive@>
 mp_primitive (mp, "/", mp_slash, mp_over);
 mp->frozen_slash = mp_frozen_primitive (mp, "/", mp_slash, mp_over);
-@:/ }{\.{/} primitive@>;
+@:/ }{\.{/} primitive@>
 mp_primitive (mp, "++", mp_tertiary_binary, mp_pythag_add);
-@:++_}{\.{++} primitive@>;
+@:++_}{\.{++} primitive@>
 mp_primitive (mp, "+-+", mp_tertiary_binary, mp_pythag_sub);
-@:+-+_}{\.{+-+} primitive@>;
+@:+-+_}{\.{+-+} primitive@>
 mp_primitive (mp, "or", mp_tertiary_binary, mp_or_op);
-@:or_}{\&{or} primitive@>;
+@:or_}{\&{or} primitive@>
 mp_primitive (mp, "and", mp_and_command, mp_and_op);
-@:and_}{\&{and} primitive@>;
+@:and_}{\&{and} primitive@>
 mp_primitive (mp, "<", mp_expression_binary, mp_less_than);
-@:< }{\.{<} primitive@>;
+@:< }{\.{<} primitive@>
 mp_primitive (mp, "<=", mp_expression_binary, mp_less_or_equal);
-@:<=_}{\.{<=} primitive@>;
+@:<=_}{\.{<=} primitive@>
 mp_primitive (mp, ">", mp_expression_binary, mp_greater_than);
-@:> }{\.{>} primitive@>;
+@:> }{\.{>} primitive@>
 mp_primitive (mp, ">=", mp_expression_binary, mp_greater_or_equal);
-@:>=_}{\.{>=} primitive@>;
+@:>=_}{\.{>=} primitive@>
 mp_primitive (mp, "=", mp_equals, mp_equal_to);
-@:= }{\.{=} primitive@>;
+@:= }{\.{=} primitive@>
 mp_primitive (mp, "<>", mp_expression_binary, mp_unequal_to);
-@:<>_}{\.{<>} primitive@>;
+@:<>_}{\.{<>} primitive@>
 mp_primitive (mp, "substring", mp_primary_binary, mp_substring_of);
-@:substring_}{\&{substring} primitive@>;
+@:substring_}{\&{substring} primitive@>
 mp_primitive (mp, "subpath", mp_primary_binary, mp_subpath_of);
-@:subpath_}{\&{subpath} primitive@>;
+@:subpath_}{\&{subpath} primitive@>
 mp_primitive (mp, "directiontime", mp_primary_binary, mp_direction_time_of);
-@:direction_time_}{\&{directiontime} primitive@>;
+@:direction_time_}{\&{directiontime} primitive@>
 mp_primitive (mp, "point", mp_primary_binary, mp_point_of);
-@:point_}{\&{point} primitive@>;
+@:point_}{\&{point} primitive@>
 mp_primitive (mp, "precontrol", mp_primary_binary, mp_precontrol_of);
-@:precontrol_}{\&{precontrol} primitive@>;
+@:precontrol_}{\&{precontrol} primitive@>
 mp_primitive (mp, "postcontrol", mp_primary_binary, mp_postcontrol_of);
-@:postcontrol_}{\&{postcontrol} primitive@>;
+@:postcontrol_}{\&{postcontrol} primitive@>
 mp_primitive (mp, "penoffset", mp_primary_binary, mp_pen_offset_of);
-@:pen_offset_}{\&{penoffset} primitive@>;
+@:pen_offset_}{\&{penoffset} primitive@>
 mp_primitive (mp, "arctime", mp_primary_binary, mp_arc_time_of);
-@:arc_time_of_}{\&{arctime} primitive@>;
+@:arc_time_of_}{\&{arctime} primitive@>
 mp_primitive (mp, "mpversion", mp_nullary, mp_version);
-@:mp_verison_}{\&{mpversion} primitive@>;
+@:mp_verison_}{\&{mpversion} primitive@>
 mp_primitive (mp, "&", mp_ampersand, mp_concatenate);
-@:!!!}{\.{\&} primitive@>;
+@:!!!}{\.{\&} primitive@>
 mp_primitive (mp, "rotated", mp_secondary_binary, mp_rotated_by);
-@:rotated_}{\&{rotated} primitive@>;
+@:rotated_}{\&{rotated} primitive@>
 mp_primitive (mp, "slanted", mp_secondary_binary, mp_slanted_by);
-@:slanted_}{\&{slanted} primitive@>;
+@:slanted_}{\&{slanted} primitive@>
 mp_primitive (mp, "scaled", mp_secondary_binary, mp_scaled_by);
-@:scaled_}{\&{scaled} primitive@>;
+@:scaled_}{\&{scaled} primitive@>
 mp_primitive (mp, "shifted", mp_secondary_binary, mp_shifted_by);
-@:shifted_}{\&{shifted} primitive@>;
+@:shifted_}{\&{shifted} primitive@>
 mp_primitive (mp, "transformed", mp_secondary_binary, mp_transformed_by);
-@:transformed_}{\&{transformed} primitive@>;
+@:transformed_}{\&{transformed} primitive@>
 mp_primitive (mp, "xscaled", mp_secondary_binary, mp_x_scaled);
-@:x_scaled_}{\&{xscaled} primitive@>;
+@:x_scaled_}{\&{xscaled} primitive@>
 mp_primitive (mp, "yscaled", mp_secondary_binary, mp_y_scaled);
-@:y_scaled_}{\&{yscaled} primitive@>;
+@:y_scaled_}{\&{yscaled} primitive@>
 mp_primitive (mp, "zscaled", mp_secondary_binary, mp_z_scaled);
-@:z_scaled_}{\&{zscaled} primitive@>;
+@:z_scaled_}{\&{zscaled} primitive@>
 mp_primitive (mp, "infont", mp_secondary_binary, mp_in_font);
-@:in_font_}{\&{infont} primitive@>;
+@:in_font_}{\&{infont} primitive@>
 mp_primitive (mp, "intersectiontimes", mp_tertiary_binary, mp_intersect);
-@:intersection_times_}{\&{intersectiontimes} primitive@>;
+@:intersection_times_}{\&{intersectiontimes} primitive@>
 mp_primitive (mp, "envelope", mp_primary_binary, mp_envelope_of);
-@:envelope_}{\&{envelope} primitive@>;
+@:envelope_}{\&{envelope} primitive@>
 mp_primitive (mp, "boundingpath", mp_primary_binary, mp_boundingpath_of);
-@:boundingpath_}{\&{boundingpath} primitive@>;
+@:boundingpath_}{\&{boundingpath} primitive@>
 mp_primitive (mp, "glyph", mp_primary_binary, mp_glyph_infont);
-@:glyph_infont_}{\&{glyph} primitive@>;
+@:glyph_infont_}{\&{glyph} primitive@>
 mp_primitive (mp, "interval_get_left_endpoint", mp_unary, mp_m_get_left_endpoint_op);  /* math interval new primitives */
-@:m_get_left_endpoint_}{\&{mget\_left\_endpoint} primitive@>;
+@:m_get_left_endpoint_}{\&{mget\_left\_endpoint} primitive@>
 mp_primitive (mp, "interval_get_right_endpoint", mp_unary, mp_m_get_right_endpoint_op); /* math interval new primitives */
-@:m_get_right_endpoint_}{\&{mget\_right\_endpoint} primitive@>;
+@:m_get_right_endpoint_}{\&{mget\_right\_endpoint} primitive@>
 mp_primitive (mp, "interval_set", mp_unary, mp_interval_set_op); /* math interval new primitives */
-@:interval_set}{\&{interval\_set} primitive@>;
+@:interval_set}{\&{interval\_set} primitive@>
 
 
 @ @<Cases of |print_cmd...@>=
@@ -25529,11 +25490,11 @@ for backward compatibility) .
 @d cur_pic_item mp_link(edge_list(cur_exp_node()))
 @d pict_color_type(A) ((cur_pic_item!=NULL) &&
          ((!has_color(cur_pic_item))
-          ||
+          || @|
          (((mp_color_model(cur_pic_item)==A)
-          ||
-          ((mp_color_model(cur_pic_item)==mp_uninitialized_model) &&
-           (number_to_scaled (internal_value(mp_default_color_model))/number_to_scaled (unity_t))==(A))))))
+          || @|
+          ((mp_color_model(cur_pic_item)==mp_uninitialized_model) && @|
+           (number_to_scaled (internal_value(mp_default_color_model))/ @| number_to_scaled (unity_t))==(A))))))
 
 @d boolean_reset(A) if ( (A) ) set_cur_exp_value_boolean(mp_true_code); else set_cur_exp_value_boolean(mp_false_code)
 
@@ -26179,7 +26140,7 @@ static void mp_bad_unary (MP mp, quarterword c) {
   delete_str_ref(sname);
   mp_disp_err(mp, NULL);
   mp_back_error (mp, msg, hlp, true);
-@.Not implemented...@>;
+@.Not implemented...@>
   mp_get_x_next (mp);
 }
 
@@ -26301,7 +26262,7 @@ static void mp_bad_color_part (MP mp, quarterword c) {
   char msg[256];
   int old_setting;
   mp_string sname;
-  const char *hlp[] = {
+  const char *hlp[] = {@|
      "You can only ask for the redpart, greenpart, bluepart of a rgb object,",
      "the cyanpart, magentapart, yellowpart or blackpart of a cmyk object, ",
      "or the greypart of a grey object. No mixing and matching, please.",
@@ -26315,7 +26276,7 @@ static void mp_bad_color_part (MP mp, quarterword c) {
   mp_print_op (mp, c);
   sname = mp_make_string(mp);
   mp->selector = old_setting;
-@.Wrong picture color model...@>;
+@.Wrong picture color model...@>
   if (mp_color_model (p) == mp_grey_model)
     mp_snprintf (msg, 256, "Wrong picture color model: %s of grey object", mp_str(mp, sname));
   else if (mp_color_model (p) == mp_cmyk_model)
@@ -26523,7 +26484,7 @@ static void mp_take_pict_part (MP mp, quarterword c) {
         add_str_ref (new_expr.data.str);
         mp_flush_cur_exp (mp, new_expr);
         mp->cur_exp.type = mp_string_type;
-      };
+      }
       break;
     case mp_prescript_part:
       if (!has_color (p)) {
@@ -26537,7 +26498,7 @@ static void mp_take_pict_part (MP mp, quarterword c) {
         }
         mp_flush_cur_exp (mp, new_expr);
         mp->cur_exp.type = mp_string_type;
-      };
+      }
       break;
     case mp_postscript_part:
       if (!has_color (p)) {
@@ -26551,7 +26512,7 @@ static void mp_take_pict_part (MP mp, quarterword c) {
         }
         mp_flush_cur_exp (mp, new_expr);
         mp->cur_exp.type = mp_string_type;
-      };
+      }
       break;
     case mp_font_part:
       if (mp_type (p) != mp_text_node_type)
@@ -26561,7 +26522,7 @@ static void mp_take_pict_part (MP mp, quarterword c) {
         add_str_ref (new_expr.data.str);
         mp_flush_cur_exp (mp, new_expr);
         mp->cur_exp.type = mp_string_type;
-      };
+      }
       break;
     case mp_path_part:
       if (mp_type (p) == mp_text_node_type) {
@@ -26637,7 +26598,7 @@ static void mp_take_pict_part (MP mp, quarterword c) {
       break;
     }                           /* all cases have been enumerated */
     return;
-  };
+  }
 NOT_FOUND:
   /* Convert the current expression to a NULL value appropriate for |c| */
   switch (c) {
@@ -26711,11 +26672,11 @@ static void mp_str_to_num (MP mp, quarterword c) {  /* converts a string to a nu
       else {
         bad_char = true;
         m = 0;
-      };
+      }
       if ((int) m >= b) {
         bad_char = true;
         m = 0;
-      };
+      }
       if (n < 32768 / b)
         n = n * b + m;
       else
@@ -26731,7 +26692,7 @@ static void mp_str_to_num (MP mp, quarterword c) {  /* converts a string to a nu
       mp_back_error (mp, "String contains illegal digits", hlp, true);
       mp_get_x_next (mp);
     }
-    if ((n > 4095)) { /* todo, this is scaled specific */
+    if ((n > 4095)) { /* TODO: this is scaled specific */
       if (number_positive (internal_value (mp_warning_check))) {
         char msg[256];
         const char *hlp[] = {
@@ -26862,7 +26823,7 @@ static void mp_bezier_slope (MP mp, mp_number *ret, mp_number AX, mp_number AY,
   }
   mp_an_angle (mp, &xo, deltax, deltay);
   a = (bx - ax) * (cy - by) - (cx - bx) * (by - ay);    /* a = (bp-ap)x(cp-bp); */
-  b = (bx - ax) * (dy - cy) - (by - ay) * (dx - cx);;   /* b = (bp-ap)x(dp-cp); */
+  b = (bx - ax) * (dy - cy) - (by - ay) * (dx - cx);   /* b = (bp-ap)x(dp-cp); */
   c = (cx - bx) * (dy - cy) - (dx - cx) * (cy - by);    /* c = (cp-bp)x(dp-cp); */
   if ((a == 0) && (c == 0)) {
     res = (b == 0 ? 0 : (mp_out (number_to_double(xo)) - mp_out (number_to_double(xi))));
@@ -27573,7 +27534,7 @@ static void mp_do_binary (MP mp, mp_node p, integer c) {
         mp_take_part (mp, part_type);
         break;
       default:
-        assert (0);                 /* todo: |mp->cur_exp.type>mp_transform_node_type| ? */
+        assert (0);                 /* TODO: |mp->cur_exp.type>mp_transform_node_type| ? */
         break;
       }
 
@@ -27603,7 +27564,7 @@ static void mp_do_binary (MP mp, mp_node p, integer c) {
       new_number(new_expr.data.n);
       set_number_from_boolean (new_expr.data.n, mp_false_code);
       mp_back_error (mp,"Unknown relation will be considered false", hlp, true);
-    @.Unknown relation...@>;
+    @.Unknown relation...@>
       mp_get_x_next (mp);
       mp_flush_cur_exp (mp, new_expr);
     } else {
@@ -27626,7 +27587,7 @@ static void mp_do_binary (MP mp, mp_node p, integer c) {
       case mp_unequal_to:
         boolean_reset (number_nonzero(cur_exp_value_number ()));
         break;
-      };                            /* there are no other cases */
+      }                            /* there are no other cases */
     }
     mp->cur_exp.type = mp_boolean_type;
   DONE:
@@ -27933,7 +27894,7 @@ static void mp_bad_binary (MP mp, mp_node p, quarterword c) {
   sname = mp_make_string(mp);
   mp->selector = old_setting;
   mp_snprintf (msg, 256, "Not implemented: %s", mp_str(mp, sname));
-@.Not implemented...@>;
+@.Not implemented...@>
   delete_str_ref(sname);
   mp_disp_err (mp, p);
   mp_disp_err (mp, NULL);
@@ -27949,7 +27910,7 @@ static void mp_bad_envelope_pen (MP mp) {
   mp_disp_err (mp, NULL);
   mp_disp_err (mp, NULL);
   mp_back_error (mp, "Not implemented: envelope(elliptical pen)of(path)", hlp, true);
-@.Not implemented...@>;
+@.Not implemented...@>
   mp_get_x_next (mp);
 }
 
@@ -28238,9 +28199,8 @@ static void mp_frac_mult (MP mp, mp_number n, mp_number d) {
   mp_node old_exp;      /* a capsule to recycle */
   mp_number v;   /* |n/d| */
   new_fraction (v);
-  if (number_greater (internal_value (mp_tracing_commands), two_t)) {
-    @<Trace the fraction multiplication@>;
-  }
+  if (number_greater (internal_value (mp_tracing_commands), two_t))
+    @<Trace the fraction multiplication@>@;
   switch (mp->cur_exp.type) {
   case mp_transform_type:
   case mp_color_type:
@@ -28442,7 +28402,7 @@ static void mp_set_up_trans (MP mp, quarterword c) {
       @<For each of the eight cases, change the relevant fields of |cur_exp|
       and |goto done|;
       but do nothing if capsule |p| doesn't have the appropriate type@>;
-    };                            /* there are no other cases */
+    }                            /* there are no other cases */
     mp_disp_err (mp, p);
     mp_back_error (mp, "Improper transformation argument", hlp, true);
     mp_get_x_next (mp);
@@ -28757,9 +28717,8 @@ if (number_nonzero(mp->txy) || number_nonzero(mp->tyx) ||
 } else {
   mp_number abs_tyy, ret;
   new_number (abs_tyy);
-  if (number_negative(mp->txx)) {
-    @<Reverse the dash list of |h|@>;
-  }
+  if (number_negative(mp->txx))
+    @<Reverse the dash list of |h|@>@;
   @<Scale the dash list by |txx| and shift it by |tx|@>;
   number_clone(abs_tyy, mp->tyy);
   number_abs (abs_tyy);
@@ -28802,16 +28761,15 @@ r = dash_list (h);
 
 
 @ @<Make the bounding box of |h| unknown if it can't be updated properly...@>=
-if (number_zero(mp->txx) && number_zero(mp->tyy)) {
-  @<Swap the $x$ and $y$ parameters in the bounding box of |h|@>;
-} else if (number_nonzero(mp->txy) || number_nonzero(mp->tyx)) {
+if (number_zero(mp->txx) && number_zero(mp->tyy))
+  @<Swap the $x$ and $y$ parameters in the bounding box of |h|@>@;
+else if (number_nonzero(mp->txy) || number_nonzero(mp->tyx)) {
   mp_init_bbox (mp, h);
   goto DONE1;
 }
-if (number_lessequal (h->minx, h->maxx)) {
+if (number_lessequal (h->minx, h->maxx))
   @<Scale the bounding box by |txx+txy| and |tyx+tyy|; then shift by
-   |(tx,ty)|@>;
-}
+   |(tx,ty)|@>@;
 DONE1:
 
 
@@ -28932,7 +28890,7 @@ set_number_to_zero(mp->ty);
 mp_number_trans (mp, &((mp_text_node)q)->txx, &((mp_text_node)q)->tyx);
 mp_number_trans (mp, &((mp_text_node)q)->txy, &((mp_text_node)q)->tyy);
 number_clone(mp->tx, sx);
-number_clone(mp->ty, sy)
+number_clone(mp->ty, sy)@;
 
 @ The hard cases of transformation occur when big nodes are involved,
 and when some of their components are unknown.
@@ -29048,9 +29006,9 @@ static void mp_bilin1 (MP mp, mp_node p, mp_number t, mp_node q,
 
 @ @<Transform a known big node@>=
 mp_set_up_trans (mp, c);
-if (mp->cur_exp.type == mp_known) {
-  @<Transform known by known@>;
-} else {
+if (mp->cur_exp.type == mp_known)
+  @<Transform known by known@>@;
+else {
   pp = mp_stash_cur_exp (mp);
   qq = value_node (pp);
   mp_make_exp_copy (mp, p);
@@ -29447,9 +29405,11 @@ static void mp_set_up_boundingpath (MP mp, mp_node p) {
 
 
 
-@ This is pretty straightfoward. The one silly thing is that
+@ This is pretty straightforward. The one silly thing is that
 the output of |mp_ps_do_font_charstring| has to be un-exported.
 
+@s mp_ps_font int
+
 @<Declare binary action...@>=
 static void mp_set_up_glyph_infont (MP mp, mp_node p) {
   mp_edge_object *h = NULL;
@@ -30001,8 +29961,7 @@ a pointer to a capsule that is to be equated to the current expression.
 @<Declare the procedure called |make_eq|@>=
 static void mp_make_eq (MP mp, mp_node lhs);
 
-@
-@c
+@ @c
 static void announce_bad_equation (MP mp, mp_node lhs) {
   char msg[256];
   const char *hlp[] = {
@@ -30174,8 +30133,7 @@ but to equate the two operands.
 @<Declarations@>=
 static void mp_try_eq (MP mp, mp_node l, mp_node r);
 
-@
-@d equation_threshold_k ((math_data *)mp->math)->equation_threshold_t
+@ @d equation_threshold_k ((math_data *)mp->math)->equation_threshold_t
 
 @c
 static void deal_with_redundant_or_inconsistent_equation(MP mp, mp_value_node p, mp_node r) {
@@ -30372,25 +30330,25 @@ mp_node mp_scan_declared_variable (MP mp) {
 
 @<Put each...@>=
 mp_primitive (mp, "numeric", mp_type_name, mp_numeric_type);
-@:numeric_}{\&{numeric} primitive@>;
+@:numeric_}{\&{numeric} primitive@>
 mp_primitive (mp, "string", mp_type_name, mp_string_type);
-@:string_}{\&{string} primitive@>;
+@:string_}{\&{string} primitive@>
 mp_primitive (mp, "boolean", mp_type_name, mp_boolean_type);
-@:boolean_}{\&{boolean} primitive@>;
+@:boolean_}{\&{boolean} primitive@>
 mp_primitive (mp, "path", mp_type_name, mp_path_type);
-@:path_}{\&{path} primitive@>;
+@:path_}{\&{path} primitive@>
 mp_primitive (mp, "pen", mp_type_name, mp_pen_type);
-@:pen_}{\&{pen} primitive@>;
+@:pen_}{\&{pen} primitive@>
 mp_primitive (mp, "picture", mp_type_name, mp_picture_type);
-@:picture_}{\&{picture} primitive@>;
+@:picture_}{\&{picture} primitive@>
 mp_primitive (mp, "transform", mp_type_name, mp_transform_type);
-@:transform_}{\&{transform} primitive@>;
+@:transform_}{\&{transform} primitive@>
 mp_primitive (mp, "color", mp_type_name, mp_color_type);
-@:color_}{\&{color} primitive@>;
+@:color_}{\&{color} primitive@>
 mp_primitive (mp, "rgbcolor", mp_type_name, mp_color_type);
-@:color_}{\&{rgbcolor} primitive@>;
+@:color_}{\&{rgbcolor} primitive@>
 mp_primitive (mp, "cmykcolor", mp_type_name, mp_cmykcolor_type);
-@:color_}{\&{cmykcolor} primitive@>;
+@:color_}{\&{cmykcolor} primitive@>
 mp_primitive (mp, "pair", mp_type_name, mp_pair_type);
 @:pair_}{\&{pair} primitive@>
 
@@ -30422,7 +30380,7 @@ void mp_do_type_declaration (MP mp) {
     q = mp_find_variable (mp, p);
     if (q != NULL) {
       mp_type (q) = t;
-      set_value_number (q, zero_t);         /* todo: this was |null| */
+      set_value_number (q, zero_t);         /* TODO: this was |NULL| */
     } else {
       const char *hlp[] = {
              "You can't use, e.g., `numeric foo[]' after `vardef foo'.",
@@ -30439,8 +30397,7 @@ void mp_do_type_declaration (MP mp) {
 }
 
 
-@
-@c
+@ @c
 static void flush_spurious_symbols_after_declared_variable (MP mp)
 {
   const char *hlp[] = {
@@ -30652,7 +30609,7 @@ static void mplib_shipout_backend (MP mp, void *h);
         if (!ff->f) {
           ff->f = xmalloc(1,1);
           (a).fptr = ff->f;
-        } } while (0)
+        } } while (0)@;
 
 @c
 static void *mplib_open_file (MP mp, const char *fname, const char *fmode,
@@ -30906,9 +30863,11 @@ mp_free_stream (&(mp->run_data.error_out));
 mp_free_stream (&(mp->run_data.ship_out));
 
 @ @<Finish non-interactive use@>=
-xfree (mp->term_out);
-xfree (mp->term_in);
-xfree (mp->err_out);
+{
+  xfree (mp->term_out);
+  xfree (mp->term_in);
+  xfree (mp->err_out);
+}
 
 @ @<Start non-interactive work@>=
 @<Initialize the output routines@>;
@@ -31055,7 +31014,7 @@ char *mp_metapost_version (void);void mp_show_library_versions (void);
 
 @ @<Put each...@>=
 mp_primitive (mp, "end", mp_stop, 0);
-@:end_}{\&{end} primitive@>;
+@:end_}{\&{end} primitive@>
 mp_primitive (mp, "dump", mp_stop, 1);
 mp->frozen_dump = mp_frozen_primitive (mp, "dump", mp_stop, 1);
 @:dump_}{\&{dump} primitive@>
@@ -31077,8 +31036,9 @@ then we'll tackle the tougher commands.
 
 Here's one of the simplest:
 
-@ @<Declare action procedures for use by |do_statement|@>=
+@<Declare action procedures for use by |do_statement|@>=
 static void mp_do_random_seed (MP mp);
+
 @ @c
 void mp_do_random_seed (MP mp) {
   mp_value new_expr;
@@ -31088,8 +31048,8 @@ void mp_do_random_seed (MP mp) {
   if (cur_cmd() != mp_assignment) {
     const char *hlp[] = { "Always say `randomseed:=<numeric expression>'.", NULL };
     mp_back_error (mp, "Missing `:=' has been inserted", hlp, true);
-@.Missing `:='@>;
-  };
+@.Missing `:='@>
+  }
   mp_get_x_next (mp);
   mp_scan_expression (mp);
   if (mp->cur_exp.type != mp_known) {
@@ -31099,12 +31059,11 @@ void mp_do_random_seed (MP mp) {
            NULL };
     mp_disp_err(mp, NULL);
     mp_back_error (mp, "Unknown value will be ignored", hlp, true);
-@.Unknown value...ignored@>;
+@.Unknown value...ignored@>
     mp_get_x_next (mp);
     mp_flush_cur_exp (mp, new_expr);
-  } else {
-    @<Initialize the random seed to |cur_exp|@>;
-  }
+  } else
+    @<Initialize the random seed to |cur_exp|@>@;
 }
 
 
@@ -31123,15 +31082,13 @@ void mp_do_random_seed (MP mp) {
 }
 
 
-@ And here's another simple one (somewhat different in flavor):
-
 @ @<Put each...@>=
 mp_primitive (mp, "batchmode", mp_mode_command, mp_batch_mode);
-@:mp_batch_mode_}{\&{batchmode} primitive@>;
+@:mp_batch_mode_}{\&{batchmode} primitive@>
 mp_primitive (mp, "nonstopmode", mp_mode_command, mp_nonstop_mode);
-@:mp_nonstop_mode_}{\&{nonstopmode} primitive@>;
+@:mp_nonstop_mode_}{\&{nonstopmode} primitive@>
 mp_primitive (mp, "scrollmode", mp_mode_command, mp_scroll_mode);
-@:mp_scroll_mode_}{\&{scrollmode} primitive@>;
+@:mp_scroll_mode_}{\&{scrollmode} primitive@>
 mp_primitive (mp, "errorstopmode", mp_mode_command, mp_error_stop_mode);
 @:mp_error_stop_mode_}{\&{errorstopmode} primitive@>
 
@@ -31156,9 +31113,9 @@ break;
 
 @ The `\&{inner}' and `\&{outer}' commands are only slightly harder.
 
-@ @<Put each...@>=
+@<Put each...@>=
 mp_primitive (mp, "inner", mp_protection_command, 0);
-@:inner_}{\&{inner} primitive@>;
+@:inner_}{\&{inner} primitive@>
 mp_primitive (mp, "outer", mp_protection_command, 1);
 @:outer_}{\&{outer} primitive@>
 
@@ -31171,7 +31128,9 @@ else
   mp_print (mp, "outer");
 break;
 
-@ @<Declare action procedures for use by |do_statement|@>=
+@ And here's another simple one (somewhat different in flavor):
+
+@<Declare action procedures for use by |do_statement|@>=
 static void mp_do_protection (MP mp);
 
 @ @c
@@ -31199,7 +31158,7 @@ declaration assigns the command code |left_delimiter| to `\.{(}' and
 |right_delimiter| to `\.{)}'; the |equiv| of each delimiter is the
 hash address of its mate.
 
-@ @<Declare action procedures for use by |do_statement|@>=
+@<Declare action procedures for use by |do_statement|@>=
 static void mp_def_delims (MP mp);
 
 @ @c
@@ -31235,7 +31194,7 @@ void mp_check_delimiter (MP mp, mp_sym l_delim, mp_sym r_delim) {
            "put one in, behind the scenes; this may fix the problem.",
             NULL };
     mp_snprintf(msg, 256, "Missing `%s' has been inserted", mp_str (mp, text (r_delim)));
-@.Missing `)'@>;
+@.Missing `)'@>
     mp_back_error (mp, msg, hlp, true);
   } else {
     char msg[256];
@@ -31245,15 +31204,15 @@ void mp_check_delimiter (MP mp, mp_sym l_delim, mp_sym r_delim) {
            "but watch out, I'll probably miss it later.",
            NULL };
     mp_snprintf(msg, 256, "The token `%s' is no longer a right delimiter", mp_str(mp, text (r_delim)));
-@.The token...delimiter@>;
+@.The token...delimiter@>
     mp_error (mp, msg, hlp, true);
   }
 }
 
 
-@ The next four commands save or change the values associated with tokens.
+@ The next two commands save or change the values associated with tokens.
 
-@ @<Declare action procedures for use by |do_statement|@>=
+@<Declare action procedures for use by |do_statement|@>=
 static void mp_do_statement (MP mp);
 static void mp_do_interim (MP mp);
 
@@ -31267,7 +31226,7 @@ void mp_do_interim (MP mp) {
        NULL };
     mp_snprintf(msg, 256, "The token `%s' isn't an internal quantity",
       (cur_sym() == NULL ? "(%CAPSULE)" : mp_str(mp, text (cur_sym()))));
-@.The token...quantity@>;
+@.The token...quantity@>
     mp_back_error (mp, msg, hlp, true);
   } else {
     mp_save_internal (mp, cur_mod());
@@ -31296,7 +31255,7 @@ void mp_do_let (MP mp) {
            "was present. The next token I read will be `something'.",
            NULL };
     mp_back_error (mp, "Missing `=' has been inserted", hlp, true);
-@.Missing `='@>;
+@.Missing `='@>
   }
   mp_get_symbol (mp);
   switch (cur_cmd()) {
@@ -31312,7 +31271,7 @@ void mp_do_let (MP mp) {
   mp_clear_symbol (mp, l, false);
   set_eq_type (l, cur_cmd());
   if (cur_cmd() == mp_tag_token)
-    set_equiv (l, 0);              /* todo: this was |null| */
+    set_equiv (l, 0);              /* TODO: this was |NULL| */
   else if (cur_cmd() == mp_defined_macro ||
            cur_cmd() == mp_secondary_primary_macro ||
            cur_cmd() == mp_tertiary_secondary_macro ||
@@ -31400,18 +31359,18 @@ in the usual way.
 @d show_token_code 0 /* show the meaning of a single token */
 @d show_stats_code 1 /* show current memory and string usage */
 @d show_code 2 /* show a list of expressions */
-@d show_var_code 3 /* show a variable and its descendents */
+@d show_var_code 3 /* show a variable and its descendants */
 @d show_dependencies_code 4 /* show dependent variables in terms of independents */
 
 @<Put each...@>=
 mp_primitive (mp, "showtoken", mp_show_command, show_token_code);
-@:show_token_}{\&{showtoken} primitive@>;
+@:show_token_}{\&{showtoken} primitive@>
 mp_primitive (mp, "showstats", mp_show_command, show_stats_code);
-@:show_stats_}{\&{showstats} primitive@>;
+@:show_stats_}{\&{showstats} primitive@>
 mp_primitive (mp, "show", mp_show_command, show_code);
-@:show_}{\&{show} primitive@>;
+@:show_}{\&{show} primitive@>
 mp_primitive (mp, "showvariable", mp_show_command, show_var_code);
-@:show_var_}{\&{showvariable} primitive@>;
+@:show_var_}{\&{showvariable} primitive@>
 mp_primitive (mp, "showdependencies", mp_show_command, show_dependencies_code);
 @:show_dependencies_}{\&{showdependencies} primitive@>
 
@@ -31453,7 +31412,7 @@ void mp_do_show (MP mp) {
     mp_get_x_next (mp);
     mp_scan_expression (mp);
     mp_print_nl (mp, ">> ");
-@.>>@>;
+@.>>@>
     mp_print_exp (mp, NULL, 2);
     mp_flush_cur_exp (mp, new_expr);
   } while (cur_cmd() == mp_comma);
@@ -31466,10 +31425,10 @@ static void mp_disp_token (MP mp);
 @ @c
 void mp_disp_token (MP mp) {
   mp_print_nl (mp, "> ");
-@.>\relax@>;
-  if (cur_sym() == NULL) {
-    @<Show a numeric or string or capsule token@>;
-  } else {
+@.>\relax@>
+  if (cur_sym() == NULL)
+    @<Show a numeric or string or capsule token@>@;
+  else {
     mp_print_text (cur_sym());
     mp_print_char (mp, xord ('='));
     if (eq_type (cur_sym()) >= mp_outer_tag)
@@ -31518,7 +31477,7 @@ mp_print (mp, " delimiter");
 #endif
 break;
 case mp_tag_token:
-if (m == 0)                     /* todo: this was |null| */
+if (m == 0)                     /* TODO: this was |NULL| */
   mp_print (mp, "tag");
 else
   mp_print (mp, "variable");
@@ -31561,7 +31520,7 @@ static void mp_do_show_stats (MP mp);
 @ @c
 void mp_do_show_stats (MP mp) {
   mp_print_nl (mp, "Memory usage ");
-@.Memory usage...@>;
+@.Memory usage...@>
   mp_print_int (mp, (integer) mp->var_used);
   mp_print_ln (mp);
   mp_print_nl (mp, "String usage ");
@@ -31583,11 +31542,11 @@ static void mp_disp_var (MP mp, mp_node p);
 void mp_disp_var (MP mp, mp_node p) {
   mp_node q;    /* traverses attributes and subscripts */
   int n;        /* amount of macro text to show */
-  if (mp_type (p) == mp_structured) {
-    @<Descend the structure@>;
-  } else if (mp_type (p) >= mp_unsuffixed_macro) {
-    @<Display a variable macro@>;
-  } else if (mp_type (p) != mp_undefined) {
+  if (mp_type (p) == mp_structured)
+    @<Descend the structure@>@;
+  else if (mp_type (p) >= mp_unsuffixed_macro)
+    @<Display a variable macro@>@;
+  else if (mp_type (p) != mp_undefined) {
     mp_print_nl (mp, "");
     mp_print_variable_name (mp, p);
     mp_print_char (mp, xord ('='));
@@ -31714,7 +31673,7 @@ void mp_do_show_whatever (MP mp) {
       mp_back_error (mp, "OK", hlp, true);
       mp_get_x_next (mp);
     }
-@.OK@>;
+@.OK@>
   }
 }
 
@@ -31725,35 +31684,35 @@ void mp_do_show_whatever (MP mp) {
 @d contour_code 1 /* command modifier for `\&{contour}' */
 @d also_code 2 /* command modifier for `\&{also}' */
 
-@ Pre and postscripts need two new identifiers:
+@ Pre- and postscripts need two new identifiers:
 
 @d with_mp_pre_script 11
 @d with_mp_post_script 13
 
 @<Put each...@>=
 mp_primitive (mp, "doublepath", mp_thing_to_add, double_path_code);
-@:double_path_}{\&{doublepath} primitive@>;
+@:double_path_}{\&{doublepath} primitive@>
 mp_primitive (mp, "contour", mp_thing_to_add, contour_code);
-@:contour_}{\&{contour} primitive@>;
+@:contour_}{\&{contour} primitive@>
 mp_primitive (mp, "also", mp_thing_to_add, also_code);
-@:also_}{\&{also} primitive@>;
+@:also_}{\&{also} primitive@>
 mp_primitive (mp, "withpen", mp_with_option, mp_pen_type);
-@:with_pen_}{\&{withpen} primitive@>;
+@:with_pen_}{\&{withpen} primitive@>
 mp_primitive (mp, "dashed", mp_with_option, mp_picture_type);
-@:dashed_}{\&{dashed} primitive@>;
+@:dashed_}{\&{dashed} primitive@>
 mp_primitive (mp, "withprescript", mp_with_option, with_mp_pre_script);
-@:with_mp_pre_script_}{\&{withprescript} primitive@>;
+@:with_mp_pre_script_}{\&{withprescript} primitive@>
 mp_primitive (mp, "withpostscript", mp_with_option, with_mp_post_script);
-@:with_mp_post_script_}{\&{withpostscript} primitive@>;
+@:with_mp_post_script_}{\&{withpostscript} primitive@>
 mp_primitive (mp, "withoutcolor", mp_with_option, mp_no_model);
-@:with_color_}{\&{withoutcolor} primitive@>;
+@:with_color_}{\&{withoutcolor} primitive@>
 mp_primitive (mp, "withgreyscale", mp_with_option, mp_grey_model);
-@:with_color_}{\&{withgreyscale} primitive@>;
+@:with_color_}{\&{withgreyscale} primitive@>
 mp_primitive (mp, "withcolor", mp_with_option, mp_uninitialized_model);
 @:with_color_}{\&{withcolor} primitive@>
 /*  \&{withrgbcolor} is an alias for \&{withcolor} */
   mp_primitive (mp, "withrgbcolor", mp_with_option, mp_rgb_model);
-@:with_color_}{\&{withrgbcolor} primitive@>;
+@:with_color_}{\&{withrgbcolor} primitive@>
 mp_primitive (mp, "withcmykcolor", mp_with_option, mp_cmyk_model);
 @:with_color_}{\&{withcmykcolor} primitive@>
 
@@ -31806,7 +31765,7 @@ picture will ever contain a color outside the legal range for \ps\ graphics.
       break;
     cp = mp_link (cp);
   }
-} while (0)
+} while (0)@;
 
 @d clear_color(A) do {
   set_number_to_zero(((mp_stroked_node)(A))->cyan);
@@ -31814,7 +31773,7 @@ picture will ever contain a color outside the legal range for \ps\ graphics.
   set_number_to_zero(((mp_stroked_node)(A))->yellow);
   set_number_to_zero(((mp_stroked_node)(A))->black);
   mp_color_model ((A)) = mp_uninitialized_model;
-} while (0)
+} while (0)@;
 
 @d set_color_val(A,B) do {
   number_clone(A, (B));
@@ -31822,23 +31781,27 @@ picture will ever contain a color outside the legal range for \ps\ graphics.
     set_number_to_zero(A);
   if (number_greater(A,unity_t))
     set_number_to_unity(A);
-} while (0)
+} while (0)@;
 
 @c
 static int is_invalid_with_list (MP mp, mp_variable_type t) {
-  return ((t == with_mp_pre_script) && (mp->cur_exp.type != mp_string_type)) ||
-        ((t == with_mp_post_script) && (mp->cur_exp.type != mp_string_type)) ||
-        ((t == (mp_variable_type) mp_uninitialized_model) &&
-         ((mp->cur_exp.type != mp_cmykcolor_type)
-          && (mp->cur_exp.type != mp_color_type)
-          && (mp->cur_exp.type != mp_known)
-          && (mp->cur_exp.type != mp_boolean_type))) || ((t == (mp_variable_type) mp_cmyk_model)
-                                                         && (mp->cur_exp.type !=
-                                                             mp_cmykcolor_type))
-        || ((t == (mp_variable_type) mp_rgb_model) && (mp->cur_exp.type != mp_color_type))
-        || ((t == (mp_variable_type) mp_grey_model) && (mp->cur_exp.type != mp_known))
-        || ((t == (mp_variable_type) mp_pen_type) && (mp->cur_exp.type != t))
-        || ((t == (mp_variable_type) mp_picture_type) && (mp->cur_exp.type != t));
+  return ((t == with_mp_pre_script) && (mp->cur_exp.type != mp_string_type)) || @|
+        ((t == with_mp_post_script) && (mp->cur_exp.type != mp_string_type)) || @|
+        ((t == (mp_variable_type) mp_uninitialized_model) && @|
+         ((mp->cur_exp.type != mp_cmykcolor_type) @|
+          && (mp->cur_exp.type != mp_color_type) @|
+          && (mp->cur_exp.type != mp_known) @|
+          && (mp->cur_exp.type != mp_boolean_type))) || @|
+        ((t == (mp_variable_type) mp_cmyk_model) @|
+          && (mp->cur_exp.type != mp_cmykcolor_type)) || @|
+        ((t == (mp_variable_type) mp_rgb_model) @|
+          && (mp->cur_exp.type != mp_color_type)) || @|
+        ((t == (mp_variable_type) mp_grey_model) @|
+          && (mp->cur_exp.type != mp_known)) || @|
+        ((t == (mp_variable_type) mp_pen_type) @|
+          && (mp->cur_exp.type != t)) || @|
+        ((t == (mp_variable_type) mp_picture_type) @|
+          && (mp->cur_exp.type != t));
 }
 static void complain_invalid_with_list (MP mp, mp_variable_type t) {
    /* Complain about improper type */
@@ -31863,7 +31826,7 @@ static void complain_invalid_with_list (MP mp, mp_variable_type t) {
    else if (t == (mp_variable_type) mp_cmyk_model)
      hlp[0] = "Next time say `withcmykcolor <known cmykcolor expression>';";
    else if (t == (mp_variable_type) mp_grey_model)
-     hlp[0] = "Next time say `withgreyscale <known numeric expression>';";;
+     hlp[0] = "Next time say `withgreyscale <known numeric expression>';";
    mp_back_error (mp, "Improper type", hlp, true);
    mp_get_x_next (mp);
    mp_flush_cur_exp (mp, new_expr);
@@ -31880,7 +31843,7 @@ void mp_scan_with_list (MP mp, mp_node p) {
   ap = MP_VOID;
   bp = MP_VOID;
   while (cur_cmd() == mp_with_option) {
-    /* todo this is not very nice: the color models have their own enumeration */
+    /* TODO: this is not very nice: the color models have their own enumeration */
     t = (mp_variable_type) cur_mod();
     mp_get_x_next (mp);
     if (t != (mp_variable_type) mp_no_model)
@@ -32199,7 +32162,7 @@ mp_edge_header_node mp_find_edges_var (MP mp, mp_node t) {
     mp->selector = old_setting;
     mp_snprintf (msg, 256, "Variable %s is the wrong type(%s)",
                  mp_str(mp, sname), mp_type_string(mp_type (p)));
-@.Variable x is the wrong type@>;
+@.Variable x is the wrong type@>
     delete_str_ref(sname);
     mp_back_error (mp, msg, hlp, true);
     mp_get_x_next (mp);
@@ -32214,7 +32177,7 @@ mp_edge_header_node mp_find_edges_var (MP mp, mp_node t) {
 
 @ @<Put each...@>=
 mp_primitive (mp, "clip", mp_bounds_command, mp_start_clip_node_type);
-@:clip_}{\&{clip} primitive@>;
+@:clip_}{\&{clip} primitive@>
 mp_primitive (mp, "setbounds", mp_bounds_command, mp_start_bounds_node_type);
 @:set_bounds_}{\&{setbounds} primitive@>
 
@@ -32276,7 +32239,7 @@ mp_node mp_start_draw_cmd (MP mp, quarterword sep) {
   return lhv;
 }
 
-@ Here is an example of how to use |start_draw_cmd|.
+@ Here is an example of how to use |mp_start_draw_cmd|.
 
 @<Declare action procedures for use by |do_statement|@>=
 static void mp_do_bounds (MP mp);
@@ -32492,8 +32455,7 @@ void mp_do_ship_out (MP mp) {
 @ The \&{everyjob} command simply assigns a nonzero value to the global variable
 |start_sym|.
 
-
-@ @<Glob...@>=
+@<Glob...@>=
 mp_sym start_sym;       /* a symbolic token to insert at beginning of job */
 
 @ @<Set init...@>=
@@ -32515,19 +32477,19 @@ mp->start_sym = NULL;
                 while ( f>g ) {
                   mp_print_char(mp, xord('0'));
                   decr(f);
-                };
+                }
                 mp_print_int(mp, (A));
-              };
+              }
               f = 0;
-          } while (0)
+          } while (0)@;
 
 @<Put each...@>=
 mp_primitive (mp, "message", mp_message_command, message_code);
-@:message_}{\&{message} primitive@>;
+@:message_}{\&{message} primitive@>
 mp_primitive (mp, "errmessage", mp_message_command, err_message_code);
-@:err_message_}{\&{errmessage} primitive@>;
+@:err_message_}{\&{errmessage} primitive@>
 mp_primitive (mp, "errhelp", mp_message_command, err_help_code);
-@:err_help_}{\&{errhelp} primitive@>;
+@:err_help_}{\&{errhelp} primitive@>
 mp_primitive (mp, "filenametemplate", mp_message_command, filename_template_code);
 @:filename_template_}{\&{filenametemplate} primitive@>
 
@@ -32548,8 +32510,7 @@ break;
 @<Declare a procedure called |no_string_err|@>;
 static void mp_do_message (MP mp);
 
-@
-@c
+@ @c
 void mp_do_message (MP mp) {
   int m;        /* the type of message */
   mp_value new_expr;
@@ -32599,7 +32560,7 @@ static void mp_no_string_err (MP mp, const char *s) {
   const char *hlp[] = {s, NULL};
   mp_disp_err(mp, NULL);
   mp_back_error (mp, "Not a string", hlp, true);
-@.Not a string@>;
+@.Not a string@>
   mp_get_x_next (mp);
 }
 
@@ -32688,7 +32649,7 @@ void mp_do_write (MP mp) {
     else {
       @<Write |t| to the file named by |cur_exp|@>;
     }
-    /* |delete_str_ref(t);| *//* todo: is this right? */
+    /* |delete_str_ref(t);| *//* TODO: is this right? */
   }
   set_number_to_zero (new_expr.data.n);
   mp_flush_cur_exp (mp, new_expr);
@@ -32699,9 +32660,9 @@ void mp_do_write (MP mp) {
 {
   @<Find |n| where |wr_fname[n]=cur_exp| and call |open_write_file| if
     |cur_exp| must be inserted@>;
-  if (mp_str_vs_str (mp, t, mp->eof_line) == 0) {
-    @<Record the end of file on |wr_file[n]|@>;
-  } else {
+  if (mp_str_vs_str (mp, t, mp->eof_line) == 0)
+    @<Record the end of file on |wr_file[n]|@>@;
+  else {
     old_setting = mp->selector;
     mp->selector = n + write_file;
     mp_print_str (mp, t);
@@ -33143,7 +33104,7 @@ static mp_node mp_tfm_check (MP mp, quarterword m) {
 @.Enormous chardp...@>
 @.Enormous charht...@>
 @.Enormous charic...@>
-@.Enormous designsize...@>;
+@.Enormous designsize...@>
     mp_back_error (mp, msg, hlp, true);
     mp_get_x_next (mp);
     if (number_positive (internal_value (m))) {
@@ -33174,13 +33135,14 @@ mp->tfm_height[c] = mp_tfm_check (mp, mp_char_ht);
 mp_free_value_node (mp, mp->tfm_depth[c]);
 mp->tfm_depth[c] = mp_tfm_check (mp, mp_char_dp);
 mp_free_value_node (mp, mp->tfm_ital_corr[c]);
-mp->tfm_ital_corr[c] = mp_tfm_check (mp, mp_char_ic)
+mp->tfm_ital_corr[c] = mp_tfm_check (mp, mp_char_ic)@;
 
 
 @ Now let's consider \MP's special \.{TFM}-oriented commands.
 
 
-@ @d char_list_code 0
+@
+@d char_list_code 0
 @d lig_table_code 1
 @d extensible_code 2
 @d header_byte_code 3
@@ -33188,13 +33150,13 @@ mp->tfm_ital_corr[c] = mp_tfm_check (mp, mp_char_ic)
 
 @<Put each...@>=
 mp_primitive (mp, "charlist", mp_tfm_command, char_list_code);
-@:char_list_}{\&{charlist} primitive@>;
+@:char_list_}{\&{charlist} primitive@>
 mp_primitive (mp, "ligtable", mp_tfm_command, lig_table_code);
-@:lig_table_}{\&{ligtable} primitive@>;
+@:lig_table_}{\&{ligtable} primitive@>
 mp_primitive (mp, "extensible", mp_tfm_command, extensible_code);
-@:extensible_}{\&{extensible} primitive@>;
+@:extensible_}{\&{extensible} primitive@>
 mp_primitive (mp, "headerbyte", mp_tfm_command, header_byte_code);
-@:header_byte_}{\&{headerbyte} primitive@>;
+@:header_byte_}{\&{headerbyte} primitive@>
 mp_primitive (mp, "fontdimen", mp_tfm_command, font_dimen_code);
 @:font_dimen_}{\&{fontdimen} primitive@>
 
@@ -33249,7 +33211,7 @@ eight_bits mp_get_code (MP mp) {                               /* scans a charac
   mp_disp_err(mp, NULL);
   set_number_to_zero (new_expr.data.n);
   mp_back_error (mp, "Invalid code has been replaced by 0", hlp, true);
-@.Invalid code...@>;
+@.Invalid code...@>
   mp_get_x_next (mp);
   mp_flush_cur_exp (mp, new_expr);
   c = 0;
@@ -33270,9 +33232,8 @@ void mp_set_tag (MP mp, halfword c, quarterword t, halfword r) {
       mp->label_loc[mp->label_ptr] = (short) r;
       mp->label_char[mp->label_ptr] = (eight_bits) c;
     }
-  } else {
-    @<Complain about a character tag conflict@>;
-  }
+  } else
+    @<Complain about a character tag conflict@>@;
 }
 
 
@@ -33297,7 +33258,7 @@ void mp_set_tag (MP mp, halfword c, quarterword t, halfword r) {
   } else {
     mp_snprintf(msg, 256, "Character code %d is already %s", c, xtra);
   }
-@.Character c is already...@>;
+@.Character c is already...@>
   mp_back_error (mp, msg, hlp, true);
   mp_get_x_next (mp);
 }
@@ -33322,7 +33283,7 @@ void mp_do_tfm_command (MP mp) {
       cc = mp_get_code (mp);
       mp_set_tag (mp, c, list_tag, cc);
       c = cc;
-    };
+    }
     break;
   case lig_table_code:
     if (mp->lig_kern == NULL)
@@ -33350,7 +33311,7 @@ void mp_do_tfm_command (MP mp) {
              NULL };
       mp_disp_err(mp, NULL);
       mp_back_error (mp, "Improper location", hlp, true);
-@.Improper location@>;
+@.Improper location@>
       mp_get_x_next (mp);
     } else {
       j = round_unscaled (cur_exp_value_number ());
@@ -33359,11 +33320,11 @@ void mp_do_tfm_command (MP mp) {
           "A colon should follow a headerbyte or fontinfo location.",
            NULL };
         mp_back_error (mp, "Missing `:' has been inserted", hlp, true);
-@.Missing `:'@>;
+@.Missing `:'@>
       }
-      if (c == header_byte_code) {
-        @<Store a list of header bytes@>;
-      } else {
+      if (c == header_byte_code)
+        @<Store a list of header bytes@>@;
+      else {
         if (mp->param == NULL) {
           int i;
           mp->param = xmalloc ((max_tfm_int + 1), sizeof (mp_number));
@@ -33391,16 +33352,15 @@ CONTINUE:
   } else {
     mp_back_input (mp);
     c = mp_get_code (mp);
-  };
-  if ((cur_cmd() == mp_colon) || (cur_cmd() == mp_double_colon)) {
-    @<Record a label in a lig/kern subprogram and |goto continue|@>;
   }
-  if (cur_cmd() == mp_lig_kern_token) {
-    @<Compile a ligature/kern command@>;
-  } else {
+  if ((cur_cmd() == mp_colon) || (cur_cmd() == mp_double_colon))
+    @<Record a label in a lig/kern subprogram and |goto continue|@>@;
+  if (cur_cmd() == mp_lig_kern_token)
+    @<Compile a ligature/kern command@>@;
+  else {
     const char *hlp[] = { "I was looking for `=:' or `kern' here.", NULL };
     mp_back_error (mp, "Illegal ligtable step", hlp, true);
-@.Illegal ligtable step@>;
+@.Illegal ligtable step@>
     next_char (mp->nl) = qi (0);
     op_byte (mp->nl) = qi (0);
     rem_byte (mp->nl) = qi (0);
@@ -33418,21 +33378,21 @@ DONE:
 
 @ @<Put each...@>=
 mp_primitive (mp, "=:", mp_lig_kern_token, 0);
-@:=:_}{\.{=:} primitive@>;
+@:=:_}{\.{=:} primitive@>
 mp_primitive (mp, "=:|", mp_lig_kern_token, 1);
-@:=:/_}{\.{=:\char'174} primitive@>;
+@:=:/_}{\.{=:\char'174} primitive@>
 mp_primitive (mp, "=:|>", mp_lig_kern_token, 5);
-@:=:/>_}{\.{=:\char'174>} primitive@>;
+@:=:/>_}{\.{=:\char'174>} primitive@>
 mp_primitive (mp, "|=:", mp_lig_kern_token, 2);
-@:=:/_}{\.{\char'174=:} primitive@>;
+@:=:/_}{\.{\char'174=:} primitive@>
 mp_primitive (mp, "|=:>", mp_lig_kern_token, 6);
-@:=:/>_}{\.{\char'174=:>} primitive@>;
+@:=:/>_}{\.{\char'174=:>} primitive@>
 mp_primitive (mp, "|=:|", mp_lig_kern_token, 3);
-@:=:/_}{\.{\char'174=:\char'174} primitive@>;
+@:=:/_}{\.{\char'174=:\char'174} primitive@>
 mp_primitive (mp, "|=:|>", mp_lig_kern_token, 7);
-@:=:/>_}{\.{\char'174=:\char'174>} primitive@>;
+@:=:/>_}{\.{\char'174=:\char'174>} primitive@>
 mp_primitive (mp, "|=:|>>", mp_lig_kern_token, 11);
-@:=:/>_}{\.{\char'174=:\char'174>>} primitive@>;
+@:=:/>_}{\.{\char'174=:\char'174>>} primitive@>
 mp_primitive (mp, "kern", mp_lig_kern_token, mp_kern_flag);
 @:kern_}{\&{kern} primitive@>
 
@@ -33483,7 +33443,7 @@ We may need to cancel skips that span more than 127 lig/kern steps.
   do {
     mp->lll=qo(skip_byte(mp->ll));
     skip_byte(mp->ll)=stop_flag; mp->ll=(short)(mp->ll-mp->lll);
-  } while (mp->lll!=0)
+  } while (mp->lll!=0)@;
 
 @d skip_error(A) {
   const char *hlp[] = { "At most 127 lig/kern steps can separate skipto1 from 1::.", NULL};
@@ -33550,7 +33510,7 @@ We may need to cancel skips that span more than 127 lig/kern steps.
       mp_disp_err(mp, NULL);
       set_number_to_zero (new_expr.data.n);
       mp_back_error (mp, "Improper kern", hlp, true);
-@.Improper kern@>;
+@.Improper kern@>
       mp_get_x_next (mp);
       mp_flush_cur_exp (mp, new_expr);
     }
@@ -33582,7 +33542,7 @@ We may need to cancel skips that span more than 127 lig/kern steps.
 @<Define an extensible recipe@>=
 {
   if (mp->ne == 256)
-    mp_fatal_error (mp, "too many extensible recipies");
+    mp_fatal_error (mp, "too many extensible recipes");
   c = mp_get_code (mp);
   mp_set_tag (mp, c, ext_tag, mp->ne);
   if (cur_cmd() != mp_colon)
@@ -33607,26 +33567,28 @@ have to sure  to update the end of stream marker to reflect the
 actual position.
 
 @<Store a list of header bytes@>=
-j--;
-if (mp->header_last<j){
-  mp->header_last=j;
-}
-do {
-  if (j >= mp->header_size) {
-    size_t l = (size_t) (mp->header_size + (mp->header_size / 4));
-    char *t = xmalloc (l, 1);
-    memset (t, 0, l);
-    (void) memcpy (t, mp->header_byte, (size_t) mp->header_size);
-    xfree (mp->header_byte);
-    mp->header_byte = t;
-    mp->header_size = (int) l;
-  }
-  mp->header_byte[j] = (char) mp_get_code (mp);
+{
+  j--;
   if (mp->header_last<j){
-    incr (mp->header_last);
+    mp->header_last=j;
   }
-  incr (j);
-} while (cur_cmd() == mp_comma)
+  do {
+    if (j >= mp->header_size) {
+      size_t l = (size_t) (mp->header_size + (mp->header_size / 4));
+      char *t = xmalloc (l, 1);
+      memset (t, 0, l);
+      (void) memcpy (t, mp->header_byte, (size_t) mp->header_size);
+      xfree (mp->header_byte);
+      mp->header_byte = t;
+      mp->header_size = (int) l;
+    }
+    mp->header_byte[j] = (char) mp_get_code (mp);
+    if (mp->header_last<j){
+      incr (mp->header_last);
+    }
+    incr (j);
+  } while (cur_cmd() == mp_comma);
+}
 
 @ @<Store a list of font dimensions@>=
 do {
@@ -33635,7 +33597,7 @@ do {
   while (j > mp->np) {
     mp->np++;
     set_number_to_zero(mp->param[mp->np]);
-  };
+  }
   mp_get_x_next (mp);
   mp_scan_expression (mp);
   if (mp->cur_exp.type != mp_known) {
@@ -33643,13 +33605,13 @@ do {
     mp_disp_err(mp, NULL);
     set_number_to_zero (new_expr.data.n);
     mp_back_error (mp, "Improper font parameter", hlp, true);
-@.Improper font parameter@>;
+@.Improper font parameter@>
     mp_get_x_next (mp);
     mp_flush_cur_exp (mp, new_expr);
   }
   number_clone (mp->param[j], cur_exp_value_number ());
   incr (j);
-} while (cur_cmd() == mp_comma)
+} while (cur_cmd() == mp_comma)@;
 
 @ OK: We've stored all the data that is needed for the \.{TFM} file.
 All that remains is to output it in the correct format.
@@ -33817,9 +33779,8 @@ static integer mp_skimp (MP mp, integer m) {
     number_clone (l, value_number (p));
     set_indep_value (p,m);
     set_number_from_addition (l_d, l, d);
-    if (number_lessequal (value_number (mp_link (p)), l_d)) {
-      @<Replace an interval of values by its midpoint@>;
-    }
+    if (number_lessequal (value_number (mp_link (p)), l_d))
+      @<Replace an interval of values by its midpoint@>@;
     q = p;
     p = mp_link (p);
   }
@@ -33870,7 +33831,7 @@ static void mp_tfm_warning (MP mp, quarterword m) {
 @.some charwds...@>
 @.some chardps...@>
 @.some charhts...@>
-@.some charics...@>;
+@.some charics...@>
   mp_print (mp, " values had to be adjusted by as much as ");
   print_number (mp->perturbation);
   mp_print (mp, "pt)");
@@ -33977,7 +33938,7 @@ static void mp_fix_design_size (MP mp) {
   if (number_less(d, unity_t) || number_greaterequal(d, fraction_half_t)) {
     if (!number_zero (d))
       mp_print_nl (mp, "(illegal design size has been changed to 128pt)");
-@.illegal design size...@>;
+@.illegal design size...@>
     set_number_from_scaled (d, 040000000);
     number_clone (internal_value (mp_design_size), d);
   }
@@ -34105,7 +34066,7 @@ Here are some utility routines for this purpose.
 @d tfm_out(A) do { /* output one byte to |tfm_file| */
   unsigned char s=(unsigned char)(A);
   (mp->write_binary_file)(mp,mp->tfm_file,(void *)&s,1);
-  } while (0)
+  } while (0)@;
 
 @c
 static void mp_tfm_two (MP mp, integer x) {                               /* output two bytes to |tfm_file| */
@@ -34119,7 +34080,7 @@ static void mp_tfm_four (MP mp, integer x) {                               /* ou
     x = x + 010000000000;       /* use two's complement for negative values */
     x = x + 010000000000;
     tfm_out ((x / three_bytes) + 128);
-  };
+  }
   x = x % three_bytes;
   tfm_out (x / number_to_scaled (unity_t));
   x = x % number_to_scaled (unity_t);
@@ -34151,8 +34112,8 @@ if (number_positive (internal_value (mp_tracing_stats)))
 mp_print_nl (mp, "Font metrics written on ");
 mp_print (mp, mp->metric_file_name);
 mp_print_char (mp, xord ('.'));
-@.Font metrics written...@>;
-(mp->close_file) (mp, mp->tfm_file)
+@.Font metrics written...@>
+(mp->close_file) (mp, mp->tfm_file)@;
 
 
 @ Integer variables |lh|, |k|, and |lk_offset| will be defined when we use
@@ -34194,7 +34155,7 @@ for (k = mp->bc; k <= mp->ec; k++) {
     tfm_out ((indep_value (mp->tfm_height[k])) * 16 + indep_value (mp->tfm_depth[k]));
     tfm_out ((indep_value (mp->tfm_ital_corr[k])) * 4 + mp->char_tag[k]);
     tfm_out (mp->char_remainder[k]);
-  };
+  }
 }
 mp->tfm_changed = 0;
 for (k = 1; k <= 4; k++) {
@@ -34263,7 +34224,7 @@ for (k = 0; k <= 255; k++) {
     mp_print_nl (mp, "(local label ");
     mp_print_int (mp, k);
     mp_print (mp, ":: was missing)");
-@.local label l:: was missing@>;
+@.local label l:: was missing@>
     cancel_skips (mp->skip_table[k]);
   }
 }
@@ -34280,7 +34241,7 @@ if (mp->lk_started) {           /* |lk_offset=1| for the special |bchar| */
     } else {
       tfm_out (255);
       tfm_out (mp->bchar);
-    };
+    }
     mp_tfm_two (mp, mp->ll + lk_offset);
     do {
       mp->label_ptr--;
@@ -34332,7 +34293,7 @@ if (mp->tfm_changed > 0) {
   } else {
     mp_print_nl (mp, "(");
     mp_print_int (mp, mp->tfm_changed);
-@.font metric dimensions...@>;
+@.font metric dimensions...@>
     mp_print (mp, " font metric dimensions");
   }
   mp_print (mp, " had to be decreased)");
@@ -34430,8 +34391,7 @@ xfree (mp->height_base);
 xfree (mp->depth_base);
 xfree (mp->font_sizes);
 
-@
-@c
+@ @c
 void mp_reallocate_fonts (MP mp, font_number l) {
   font_number f;
   XREALLOC (mp->font_enc_name, l, char *);
@@ -34498,7 +34458,7 @@ The corresponding words in the width, height, and depth tables are stored as
 |scaled| values in units of \ps\ points.
 
 With the macros below, the |char_info| word for character~|c| in font~|f| is
-|char_mp_info(f,c)| and the width is
+|char_mp_info(f,c)| and the width~is
 $$\hbox{|char_width(f,char_mp_info(f,c)).sc|.}$$
 
 @d char_mp_info(A,B) mp->font_info[mp->char_base[(A)]+(B)].qqqq
@@ -34574,7 +34534,7 @@ void mp_lost_warning (MP mp, font_number f, int k) {
     if (mp->selector == log_only)
       incr (mp->selector);
     mp_print_nl (mp, "Missing character: There is no ");
-@.Missing character@>;
+@.Missing character@>
     mp_print_int (mp, k);
     mp_print (mp, " in font ");
     mp_print (mp, mp->font_name[f]);
@@ -34612,9 +34572,8 @@ void mp_set_text_box (MP mp, mp_text_node p) {
   ec = mp->font_ec[f];
   kk = mp_text_p (p)->len;
   k = 0;
-  while (k < kk) {
-    @<Adjust |p|'s bounding box to contain |str_pool[k]|; advance |k|@>;
-  }
+  while (k < kk)
+    @<Adjust |p|'s bounding box to contain |str_pool[k]|; advance |k|@>@;
   @<Set the height and depth to zero if the bounding box is empty@>;
   free_number (h);
   free_number (d);
@@ -34666,18 +34625,18 @@ static void mp_do_mapline (MP mp);
 static void mp_do_mapfile (MP mp) {
   mp_get_x_next (mp);
   mp_scan_expression (mp);
-  if (mp->cur_exp.type != mp_string_type) {
-    @<Complain about improper map operation@>;
-  } else {
+  if (mp->cur_exp.type != mp_string_type)
+    @<Complain about improper map operation@>@;
+  else {
     mp_map_file (mp, cur_exp_str ());
   }
 }
 static void mp_do_mapline (MP mp) {
   mp_get_x_next (mp);
   mp_scan_expression (mp);
-  if (mp->cur_exp.type != mp_string_type) {
-    @<Complain about improper map operation@>;
-  } else {
+  if (mp->cur_exp.type != mp_string_type)
+    @<Complain about improper map operation@>@;
+  else {
     mp_map_line (mp, cur_exp_str ());
   }
 }
@@ -34693,7 +34652,7 @@ static void mp_do_mapline (MP mp) {
 
 
 @ To print |scaled| value to PDF output we need some subroutines to ensure
-accurary.
+accuracy.
 
 @d max_integer   0x7FFFFFFF /* $2^{31}-1$ */
 
@@ -34719,7 +34678,7 @@ file named according to the current \&{charcode}.
 
 This is the only backend function that remains in the main |mpost.w| file.
 There are just too many variable accesses needed for status reporting
-etcetera to make it worthwile to move the code to |psout.w|.
+etcetera to make it worthwhile to move the code to |psout.w|.
 
 @<Internal library declarations@>=
 void mp_open_output_file (MP mp);
@@ -34754,7 +34713,7 @@ char *mp_set_output_file_name (MP mp, integer c) {
     if (c < 0)
       s = xstrdup (".ps");
     else
-      @<Use |c| to compute the file extension |s|@>;
+      @<Use |c| to compute the file extension |s|@>@;
     mp_pack_job_name (mp, s);
     free (s);
     ss = xstrdup (mp->name_of_file);
@@ -34889,7 +34848,7 @@ char *mp_set_output_file_name (MP mp, integer c) {
           if (n->len == 0)
             n = mp_make_string (mp);
         mp_print_char (mp, *(ftemplate->str + i));
-      };
+      }
       incr (i);
     }
     s = mp_make_string (mp);
@@ -34992,13 +34951,13 @@ else if ((mp->term_offset > 0) || (mp->file_offset > 0))
   mp_print_char (mp, xord (' '));
 mp_print_char (mp, xord ('['));
 if (c >= 0)
-  mp_print_int (mp, c)
+  mp_print_int (mp, c)@;
 
 
 @ @<End progress report@>=
 mp_print_char (mp, xord (']'));
 update_terminal();
-incr (mp->total_shipped)
+incr (mp->total_shipped)@;
 
 
 @ @<Explain what output files were written@>=
@@ -35050,9 +35009,9 @@ static void mp_do_special (MP mp);
 void mp_do_special (MP mp) {
   mp_get_x_next (mp);
   mp_scan_expression (mp);
-  if (mp->cur_exp.type != mp_string_type) {
-    @<Complain about improper special operation@>;
-  } else {
+  if (mp->cur_exp.type != mp_string_type)
+    @<Complain about improper special operation@>@;
+  else {
     mp_link (mp->last_pending) = mp_stash_cur_exp (mp);
     mp->last_pending = mp_link (mp->last_pending);
     mp_link (mp->last_pending) = NULL;
@@ -35072,9 +35031,9 @@ void mp_do_special (MP mp) {
 @ On the export side, we need an extra object type for special strings.
 
 @<Graphical object codes@>=
-mp_special_code = 8,
+mp_special_code = 8,@[@]@;
 
-@ @<Export pending specials@>=
+@ @s mp_special_object int @<Export pending specials@>=
 p = mp_link (mp->spec_head);
 while (p != NULL) {
   mp_special_object *tp;
@@ -35089,7 +35048,7 @@ while (p != NULL) {
 }
 mp_flush_token_list (mp, mp_link (mp->spec_head));
 mp_link (mp->spec_head) = NULL;
-mp->last_pending = mp->spec_head
+mp->last_pending = mp->spec_head@;
 
 @ We are now ready for the main output procedure.  Note that the |selector|
 setting is saved in a global variable so that |begin_diagnostic| can access it.
@@ -35099,13 +35058,21 @@ static void mp_ship_out (MP mp, mp_node h);
 
 @ Once again, the |gr_XXXX| macros are defined in |mppsout.h|
 
+@s mp_edge_object int
+@s mp_graphic_object int
+@s mp_text_object int
+@s mp_fill_object int
+@s mp_stroked_object int
+@s mp_clip_object int
+@s mp_bounds_object int
+
 @d export_color(q,p)
   if ( mp_color_model(p)==mp_uninitialized_model ) {
-    gr_color_model(q)  = (unsigned char)(number_to_scaled (internal_value(mp_default_color_model))/65536);
+    gr_color_model(q)  = (unsigned char)@|(number_to_scaled (internal_value(mp_default_color_model))/65536);
     gr_cyan_val(q)     = 0;
 	gr_magenta_val(q)  = 0;
 	gr_yellow_val(q)   = 0;
-	gr_black_val(q)    = ((gr_color_model(q)==mp_cmyk_model ? number_to_scaled (unity_t) : 0) / 65536.0);
+	gr_black_val(q)    = ((gr_color_model(q)==mp_cmyk_model ? @| number_to_scaled (unity_t) : 0) / 65536.0);
   } else {
     gr_color_model(q)  = (unsigned char)mp_color_model(p);
     gr_cyan_val(q)     = number_to_double(p->cyan);
@@ -35349,8 +35316,7 @@ void mp_ship_out (MP mp, mp_node h) {                               /* output ed
 @ @<Declarations@>=
 static void mp_shipout_backend (MP mp, void *h);
 
-@
-@c
+@ @c
 void mp_shipout_backend (MP mp, void *voidh) {
   char *s;
   mp_edge_object *hh;   /* the first graphical object */
@@ -35374,7 +35340,7 @@ void mp_shipout_backend (MP mp, void *voidh) {
 
 
 @ @<Exported types@>=
-typedef void (*mp_backend_writer) (MP, void *);
+typedef void @[@] (*mp_backend_writer) (MP, void *);
 
 @ @<Option variables@>=
 mp_backend_writer shipout_backend;
@@ -35459,7 +35425,7 @@ boolean mp_load_preload_file (MP mp) {
   mp->reading_preload = true;
   do {
     mp_do_statement (mp);
-  } while (!(cur_cmd() == mp_stop));     /* "dump" or EOF */
+  } while (!(cur_cmd() == mp_stop));     /* ``dump'' or EOF */
   mp->reading_preload = false;
   mp_primitive (mp, "dump", mp_relax, 0); /* reset |dump| */
   while (mp->input_ptr > 0) {
@@ -35473,10 +35439,10 @@ boolean mp_load_preload_file (MP mp) {
   while (mp->open_parens > 0) {
     mp_print (mp, " )");
     decr (mp->open_parens);
-  };
+  }
   while (mp->cond_ptr != NULL) {
     mp_print_nl (mp, "(dump occurred when ");
-@.dump occurred...@>;
+@.dump occurred...@>
     mp_print_cmd_mod (mp, mp_fi_or_else, mp->cur_if);
     /* `\.{if}' or `\.{elseif}' or `\.{else}' */
     if (mp->if_line != 0) {
@@ -35538,7 +35504,7 @@ void mp_close_files_and_terminate (MP mp) {
     mp->selector = mp->selector - 2;
     if (mp->selector == term_only) {
       mp_print_nl (mp, "Transcript written on ");
-@.Transcript written...@>;
+@.Transcript written...@>
       mp_print (mp, mp->log_name);
       mp_print_char (mp, xord ('.'));
     }
@@ -35613,7 +35579,7 @@ if (mp->log_opened) {
   char s[128];
   wlog_ln (" ");
   wlog_ln ("Here is how much of MetaPost's memory you used:");
-@.Here is how much...@>;
+@.Here is how much...@>
   mp_snprintf (s, 128, " %i string%s using %i character%s",
                (int) mp->max_strs_used, (mp->max_strs_used != 1 ? "s" : ""),
                (int) mp->max_pl_used, (mp->max_pl_used != 1 ? "s" : ""));
@@ -35632,7 +35598,7 @@ if (mp->log_opened) {
   wlog_ln (s);
 }
 
-@ It is nice to have have some of the stats available from the API.
+@ It is nice to have some of the stats available from the API.
 
 @<Exported function ...@>=
 int mp_memory_usage (MP mp);
@@ -35660,7 +35626,7 @@ been scanned.
 
 @c
 void mp_final_cleanup (MP mp) {
-  /* -Wunused: integer c; */   /* 0 for \&{end}, 1 for \&{dump} */
+  /* \.{-Wunused}: integer c; */   /* 0 for \&{end}, 1 for \&{dump} */
   /* clang: never read: |c = cur_mod();| */
   if (mp->job_name == NULL)
     mp_open_log_file (mp);
@@ -35675,10 +35641,10 @@ void mp_final_cleanup (MP mp) {
   while (mp->open_parens > 0) {
     mp_print (mp, " )");
     decr (mp->open_parens);
-  };
+  }
   while (mp->cond_ptr != NULL) {
     mp_print_nl (mp, "(end occurred when ");
-@.end occurred...@>;
+@.end occurred...@>
     mp_print_cmd_mod (mp, mp_fi_or_else, mp->cur_if);
     /* `\.{if}' or `\.{elseif}' or `\.{else}' */
     if (mp->if_line != 0) {
@@ -35697,7 +35663,7 @@ void mp_final_cleanup (MP mp) {
         mp->selector = term_only;
         mp_print_nl (mp,
                      "(see the transcript file for additional information)");
-@.see the transcript file...@>;
+@.see the transcript file...@>
         mp->selector = term_and_log;
       }
 }
diff --git a/source/texk/web2c/omegafonts/Makefile.in b/source/texk/web2c/omegafonts/Makefile.in
index a63ee7d60..385af83c8 100644
--- a/source/texk/web2c/omegafonts/Makefile.in
+++ b/source/texk/web2c/omegafonts/Makefile.in
@@ -108,6 +108,7 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/web2c-disable.m4 \
 	$(top_srcdir)/../../m4/kpse-harfbuzz-flags.m4 \
 	$(top_srcdir)/../../m4/kpse-icu-flags.m4 \
 	$(top_srcdir)/../../m4/kpse-kpathsea-flags.m4 \
+	$(top_srcdir)/../../m4/kpse-largefile.m4 \
 	$(top_srcdir)/../../m4/kpse-lex.m4 \
 	$(top_srcdir)/../../m4/kpse-lib-version.m4 \
 	$(top_srcdir)/../../m4/kpse-libpng-flags.m4 \
diff --git a/source/texk/web2c/ptexdir/ChangeLog b/source/texk/web2c/ptexdir/ChangeLog
index 73a3fbe1c..2fe03aef7 100644
--- a/source/texk/web2c/ptexdir/ChangeLog
+++ b/source/texk/web2c/ptexdir/ChangeLog
@@ -1,3 +1,9 @@
+2024-05-18  Hironori Kitagawa  <h_kitagawa2001@yahoo.co.jp>
+
+	* ptex-base.ch: Enable to get character codes
+	from control symbols by using backquote "`".
+	https://github.com/texjporg/tex-jp-build/issues/167
+
 2024-04-14  TANAKA Takuji  <ttk@t-lab.opal.ne.jp>
 
 	* ptriptest.test:
diff --git a/source/texk/web2c/ptexdir/ptex-base.ch b/source/texk/web2c/ptexdir/ptex-base.ch
index 3ed7b821e..6b77387d5 100644
--- a/source/texk/web2c/ptexdir/ptex-base.ch
+++ b/source/texk/web2c/ptexdir/ptex-base.ch
@@ -2582,14 +2582,15 @@ if cur_tok<cs_token_flag then
   end
 else if cur_tok<cs_token_flag+single_base then
   cur_val:=cur_tok-cs_token_flag-active_base
-else
-  { the token is a CS;
-    * if |kanji|<=|cur_cmd|<=|max_char_code|, then CS is let-equal to |wchar_token|
-    * if |max_char_code|<|cur_cmd|, then CS is a multibyte CS
-      => both case should raise "Improper ..." error
-    * otherwise it should be a single-character CS with |cur_val|<=255 }
-  begin if not (cur_cmd<kanji) then cur_cmd:=invalid_char;
-  cur_val:=cur_tok-cs_token_flag-single_base;
+else if cur_tok<cs_token_flag+null_cs then
+  cur_val:=cur_tok-cs_token_flag-single_base
+else { check the cs is a single Japanese character }
+  begin m:=text(cur_tok-cs_token_flag);
+    if str_start[m+1]-str_start[m]
+       = multistrlenshort(str_pool, str_start[m+1], str_start[m])
+       then
+      cur_val:=fromBUFFshort(str_pool, str_start[m+1], str_start[m])
+    else begin cur_cmd:=invalid_char; cur_val:=256; end;
   end;
 if (cur_val>255)and(cur_cmd<kanji) then
   begin print_err("Improper alphabetic or KANJI constant");
diff --git a/source/texk/web2c/uptexdir/ChangeLog b/source/texk/web2c/uptexdir/ChangeLog
index 7637aed37..a68dbcce2 100644
--- a/source/texk/web2c/uptexdir/ChangeLog
+++ b/source/texk/web2c/uptexdir/ChangeLog
@@ -1,3 +1,10 @@
+2024-05-18  Hironori Kitagawa  <h_kitagawa2001@yahoo.co.jp>
+
+	* ptex-base.ch: Enable to get character codes
+	from control symbols by using backquote "`".
+	* tests/ctlsym_num.tex: Add a test file.
+	https://github.com/texjporg/tex-jp-build/issues/167
+
 2024-05-11  TANAKA Takuji  <ttk@t-lab.opal.ne.jp>
 
 	* uptex-m.ch: Fix unmatched begin-end grouping
diff --git a/source/texk/web2c/uptexdir/ptex-base.ch b/source/texk/web2c/uptexdir/ptex-base.ch
index 3ed7b821e..6b77387d5 100644
--- a/source/texk/web2c/uptexdir/ptex-base.ch
+++ b/source/texk/web2c/uptexdir/ptex-base.ch
@@ -2582,14 +2582,15 @@ if cur_tok<cs_token_flag then
   end
 else if cur_tok<cs_token_flag+single_base then
   cur_val:=cur_tok-cs_token_flag-active_base
-else
-  { the token is a CS;
-    * if |kanji|<=|cur_cmd|<=|max_char_code|, then CS is let-equal to |wchar_token|
-    * if |max_char_code|<|cur_cmd|, then CS is a multibyte CS
-      => both case should raise "Improper ..." error
-    * otherwise it should be a single-character CS with |cur_val|<=255 }
-  begin if not (cur_cmd<kanji) then cur_cmd:=invalid_char;
-  cur_val:=cur_tok-cs_token_flag-single_base;
+else if cur_tok<cs_token_flag+null_cs then
+  cur_val:=cur_tok-cs_token_flag-single_base
+else { check the cs is a single Japanese character }
+  begin m:=text(cur_tok-cs_token_flag);
+    if str_start[m+1]-str_start[m]
+       = multistrlenshort(str_pool, str_start[m+1], str_start[m])
+       then
+      cur_val:=fromBUFFshort(str_pool, str_start[m+1], str_start[m])
+    else begin cur_cmd:=invalid_char; cur_val:=256; end;
   end;
 if (cur_val>255)and(cur_cmd<kanji) then
   begin print_err("Improper alphabetic or KANJI constant");
diff --git a/source/texk/web2c/uptexdir/tests/ctlsym_num.tex b/source/texk/web2c/uptexdir/tests/ctlsym_num.tex
new file mode 100644
index 000000000..40f695b60
--- /dev/null
+++ b/source/texk/web2c/uptexdir/tests/ctlsym_num.tex
@@ -0,0 +1,69 @@
+% Copyright 2024 Japanese TeX Development Community <issue@texjp.org>
+% You may freely use, modify and/or distribute this file.
+%
+\scrollmode
+\newlinechar=10
+
+
+%
+% Following runs on ptex, uptex, eptex and euptex
+%
+\count255=0
+
+\count255=`♪ \relax
+\message{P: \the\count255^^J}
+
+\def\♪{baz}
+\def\雪{qux}
+
+\count255=0
+\count255=`\♪ \relax
+\message{Q: \the\count255. ♪\string\♪ \♪^^J}
+
+\count255=0
+\count255=`雪 \relax
+\message{R: \the\count255^^J}
+\count255=0
+\count255=`\雪 \relax
+\message{S: \the\count255. 雪\string\雪 \雪^^J}
+
+\message{\expandafter\meaning\csname ♪\endcsname.^^J}
+\message{\expandafter\meaning\csname 雪\endcsname.^^J}
+\ifx\Uchar\undefined\else
+\message{\expandafter\meaning\csname \Uchar\jis"2276\endcsname.^^J}
+\message{\expandafter\meaning\csname \Uchar\jis"4063\endcsname.^^J}
+\fi
+
+%
+% Following runs on euptex
+%
+\ifnum\jis"2121="3000
+\ifx\Uchar\undefined
+\else
+
+\count1000=0
+
+\def\🍌{foo}
+\def\𝕯{bar}
+\count1000=`🍌 \relax
+\message{A: \the\count1000^^J}
+\count1000=0
+\count1000=`\🍌 \relax
+\message{B: \the\count1000. 🍌\string\🍌 \🍌^^J}
+
+\count1000=0
+\count1000=`𝕯 \relax
+\message{C: \the\count1000^^J}
+\count1000=0
+\count1000=`\𝕯 \relax
+\message{D: \the\count1000. 𝕯 \string\𝕯  \𝕯^^J}
+
+\message{\expandafter\meaning\csname 🍌\endcsname.^^J}
+\message{\expandafter\meaning\csname 𝕯\endcsname.^^J}
+\message{\expandafter\meaning\csname \Uchar"1F34C\endcsname.^^J}
+\message{\expandafter\meaning\csname \Uchar"1D56F\endcsname.^^J}
+
+\fi
+\fi
+
+\bye