MathType Output Translator 1.0: "MathML 1.0", "MathML 1.0 translator v1.00 by Design Science, Inc."

// Copyright (c) 2001-2010 by Design Science, Inc.
// License: You are allowed to create your own translators based on the contents of this file
// solely for use with MathType. It is recommended that you change the filename, title, and description
// in the first line of this file so as to reflect your modifications and the change of author and purpose.
// Design Science, Inc. is not responsible for any damages caused by the use of this file or derived works.

// $Header: /MathType/Translators/MathML1.tdl 15    1/19/10 12:34p Jimm $

// ============================================================
// generic template and entity rules 
// ============================================================
//
// MATHML1.TDL is based on MathML1base.tdl, where generic MathML 
// templates and entity translations are defined.  

include "MathML1base.tdl";

// ============================================================
// Default definitions for translation error handling 
// ============================================================

// Default character translation 
defchar   = error "no equivalent MathML/STIX char: <FullDesc>";         
// default template translation 
deftmpl   = error "no equivalent MathML template: $n    <Cmd> -- <Desc>";
// default embellishment
defemb   = error "no equivalent MathML template: $n    <Cmd> -- <Desc>";


// ============================================================
// Some fence constructs
// ============================================================

// In some MathML renderers, certain fence constructs are handled in a
// non-standard way.  The official MathML/STIX constructs are given here.

// double bars (both)
dbar          = "<mrow><mo>&Verbar;</mo> #1 <mo>&Verbar;</mo></mrow>";  
// double bars (left)
dbar/l        = "<mrow><mo>&Verbar;</mo>#1</mrow>";               
// double bars (right)
dbar/r        = "<mrow>#1<mo>&Verbar;</mo></mrow>";               
// Open brackets 
obrack        = "<mrow><mo>&lopenb;</mo>#1<mo>&ropenb;</mo></mrow>";         
// Left open bracket 
obrack/l      = "<mrow><mo>&lopenb;</mo>#1</mrow>";          
// Right open bracket 
obrack/r      = "<mrow>#1<mo>&ropenb;</mo></mrow>";          

// ============================================================
// Over and under braces
// ============================================================

// Brace and bracket characters have several common aliases
// STIX names are specified here
//
// Synonyms:
//
//   undcub, underbrace, UnderBrace, clb (WebEQ non-standard)
//   ovrcub, overbrace, OverBrace, cub (WebEQ non-standard)
//   undbrk, UnderBracket
//   ovrbrk, OverBracket

// horizontal brace (lower)
hbrace        = "<munder>$+$n<munder>$+$n#1$n<mo stretchy='true'>&undcub;</mo>$-$n"
                "</munder>$n#2$-$n</munder>$n";
// horizontal brace (top)
hbrace/t      = "<mover>$+$n<mover>$+$n#1$n<mo stretchy='true'>&ovrcub;</mo>$-$n"
                "</mover>$n#2$-$n</mover>$n";

// horizontal bracket (lower)
hbrack        = "<munder>$+$n<munder>$+$n#1$n<mo stretchy='true'>&undbrk;</mo>$-$n"
                "</munder>$n#2$-$n</munder>$n";
// horizontal bracket (top)
hbrack/t      = "<mover>$+$n<mover>$+$n#1$n<mo stretchy='true'>&ovbrk;</mo>$-$n"
                "</mover>$n#2$-$n</mover>$n";


// ============================================================
// integrals
// ============================================================

// Integral operators have several common aliases:
// Stix style names are specified here
//
// Synonyms:
//
//   iint, Int
//   iiint, tint
//   conint, oint, ContourIntegral
//   Conint, DoubleContourIntegral
//   cwconint, CounterClockwiseContourIntegral
//   awconint, ClockwiseContourIntegral

// double integral, no limits 
int/2/nol    = "<mrow><mo>&Int;</mo>$+$n#1$-$n</mrow>$n";

// double integral, no limits 
int/2/ex/nol = "<mrow><mo stretchy='true'>&Int;</mo>$+$n#1$-$n</mrow>$n";

// double summation-style integral, lower limit 
int/2/sum    = "<mrow>$+$n<munder>$+$n<mo>&Int;</mo>$n#2$-$n</munder>"
               "$n#1$-$n</mrow>$n";

// double stretchy summation-style integral, lower limit 
int/2/ex/sum = "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&Int;</mo>"
               "$n#2$-$n</munder>$n#1$-$n</mrow>$n";

// double integral, lower limit 
int/2        = "<mrow>$+$n<msub>$+$n<mo>&Int;</mo>$n#2$-$n</msub>$n#1"
               "$n#1$-$n</mrow>$n";

// double integral, lower limit 
int/2/ex     = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&Int;</mo>$n#2$-$n"
               "</msub>$n#1$n#1$-$n</mrow>$n";

// triple integral, no limits 
int/3/nol    = "<mrow>$+$n<mo>&tint;</mo>$n#1$-$n</mrow>$n";

// triple stretchy integral, no limits 
int/3/ex/nol    = "<mrow>$+$n<mo stretchy='true'>&tint;</mo>$n#1$-$n</mrow>$n";

// triple summation-style integral, lower limit           
int/3/sum    = "<mrow>$+$n<munder>$+$n<mo>&tint;</mo>$n#2$-$n</munder>"
               "$n#1$-$n</mrow>$n";

// triple stretchy summation-style integral, lower limit           
int/3/ex/sum = "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&tint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";

// triple integral, lower limit 
int/3        = "<mrow>$+$n<msub>$+$n<mo>&tint;</mo>$n#2$-$n</msub>$n#1$-$n</mrow>$n";

// triple integral, lower limit 
int/3/ex     = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&tint;</mo>$n#2$-$n</msub>"
               "$n#1$-$n</mrow>$n";

// contour integral, no limits 
int/c/nol    = "<mrow><mo>&conint;</mo>$+$n#1$-$n</mrow>$n";                           

// stretchy contour integral, no limits 
int/ex/c/nol    = "<mrow><mo stretchy='true'>&conint;</mo>$+$n#1$-$n</mrow>$n";

// contour summation-style integral, lower limit 
int/c/sum    = "<mrow>$+$n<munder>$+$n<mo>&conint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";      

// stretchy contour summation-style integral, lower limit 
int/ex/c/sum = "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&conint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";      

// contour integral, lower limit 
int/c        = "<mrow>$+$n<msub>$+$n<mo>&conint;</mo>$n#2$-$n</msub>"
               "$n#1$-$n</mrow>$n";

// stretchy contour integral, lower limit 
int/ex/c     = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&conint;</mo>"
               "$n#2$-$n</msub>$n#1$-$n</mrow>$n";

// area integral, no limits 
int/2/c/nol  = "<mrow><mo>&Conint;</mo>$+$n#1$-$n</mrow>";

// stretchy area integral, no limits 
int/2/ex/c/nol  = "<mrow><mo stretchy='true'>&Conint;</mo>$+$n#1$-$n</mrow>";

// area summation-style integral, lower limit 
int/2/c/sum  = "<mrow>$+$n<munder>$+$n<mo>&Conint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";

// stretchy area summation-style integral, lower limit 
int/2/ex/c/sum  = "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&Conint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";

// area integral, lower limit 
int/2/c         = "<mrow>$+$n<msub>$+$n<mo>&Conint;</mo>$n#2$-$n</msub>"
                  "$n#1$-$n</mrow>$n";

// stretchy area integral, lower limit 
int/2/ex/c      = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&Conint;</mo>$n#2$-$n"
                  "</msub>$n#1$-$n</mrow>$n";

// volume integral, no limits 
int/3/c/nol      = "<mrow>$+$n<mo>&Cconint;</mo>$n#1$-$n</mrow>$n";

// stretchy volume integral, no limits 
int/3/ex/c/nol   = "<mrow>$+$n<mo stretchy='true'>&Cconint;</mo>$n#1$-$n</mrow>$n";

// volume summation-style integral, lower limit 
int/3/c/sum      = "<mrow>$+$n<munder>$+$n<mo>&Cconint;</mo>$n#2$-$n"
                   "</munder>$n#1$-$n</mrow>$n";  

// stretchy volume summation-style integral, lower limit 
int/3/ex/c/sum  = "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&Cconint;</mo>$n#2$-$n"
                  "</munder>$n#1$-$n</mrow>$n";  

// volume integral, lower limit 
int/3/c         = "<mrow>$+$n<msub>$+$n<mo>&Cconint;</mo>$n#2$-$n</msub>"
                  "$n#1$-$n</mrow>$n";  

// stretchy volume integral, lower limit 
int/3/ex/c      = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&Cconint;</mo>$n#2$-$n"
                  "</msub>$n#1$-$n</mrow>$n";  

// counterclockwise contour integral
int/ccw/nol     = "<mrow>$+$n<mo>&awconint;</mo>$n#1$-$n</mrow>$n";

// stretchy counterclockwise contour integral
int/ex/ccw/nol  = "<mrow>$+$n<mo stretchy='true'>&awconint;</mo>$n#1$-$n</mrow>$n";

// counterclockwise contour integral, lower limit
int/ccw/sum  = "<mrow>$+$n<munder>$+$n<mo>&awconint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";          

// stretchy counterclockwise contour integral, lower limit
int/ex/ccw/sum  = "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&awconint;</mo>$n#2$-$n"
                  "</munder>$n#1$-$n</mrow>$n";          

// counterclockwise contour integral, subscript limit
int/ccw      = "<mrow>$+$n<msub>$+$n<mo>&awconint;</mo>$n#2$-$n</msub>"
               "$n#1$-$n</mrow>$n";

// stretchy counterclockwise contour integral, subscript limit
int/ex/ccw   = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&awconint;</mo>"
               "$n#2$-$n</msub>$n#1$-$n</mrow>$n";

// clockwise contour integral
int/cw/nol   =  "<mrow>$+$n<mo>&cwconint;</mo>$n#1$-$n</mrow>$n";

// stretchy clockwise contour integral
int/ex/cw/nol =  "<mrow>$+$n<mo stretchy='true'>&cwconint;</mo>$n#1$-$n</mrow>$n";

// clockwise contour integral, lower limit
int/cw/sum   =  "<mrow>$+$n<munder>$+$n<mo>&cwconint;</mo>$n#2$-$n"
               "</munder>$n#1$-$n</mrow>$n";

// stretchy clockwise contour integral, lower limit
int/ex/cw/sum  =  "<mrow>$+$n<munder>$+$n<mo stretchy='true'>&cwconint;</mo>"
                  "$n#2$-$n</munder>$n#1$-$n</mrow>$n";

// clockwise contour integral, subscript limit
int/cw       = "<mrow>$+$n<msub>$+$n<mo>&cwconint;</mo>$n#2$-$n</msub>"
               "$n#1$-$n</mrow>$n";

// clockwise contour integral, subscript limit
int/ex/cw    = "<mrow>$+$n<msub>$+$n<mo stretchy='true'>&cwconint;</mo>"
               "$n#2$-$n</msub>$n#1$-$n</mrow>$n";


// ============================================================
// Bars Hats, Tildes, etc (wide ones, over several characters)
// ============================================================

// Math diacriticals have several common aliases.
// STIX names are specified here.  Some are faked or replaced
// with near equivalents.
//
// Synonyms:
//
//   bar, macr
//   bar, lowbar
//   hat, circ
//   rarr, rightarrow
//   larr, leftarrow, LeftArrow
//   harr, leftrightarrow
//   vec (WebEQ specific), rharu, rightharpoonup, RightVector
//   rhard, rightharpoondown

// arc
arc      = "<mover accent='true'>$+$n#1$n<mo stretchy='true'>&frown;</mo>$-$n</mover>$n";

// hat 
hat      = "<mover accent='true'>$+$n#1$n<mo stretchy='true'>&circ;</mo>$-$n</mover>$n";

// over-bar 
obar        = "<mover accent='true'>$+$n#1$n<mo>&macr;</mo>$-$n</mover>$n";

// double over-bar 
obar/2      = "<mover accent='true'>$+$n<mover accent='true'>$+$n#1$n"
              "<mo stretchy='true'>&macr;</mo>$-$n</mover>$-$n"
              "<mo stretchy='true'>&macr;</mo>$-$n</mover>$n";
// under-bar 
ubar        = "<munder accentunder='true'>$+$n#1$n<mo stretchy='true'>&lowbar;</mo>$-$n"
              "</munder>$n";

// double under-bar 
ubar/2      = "<munder accentunder='true'>$+$n#1$n<mo stretchy='true'>&d2lowbar;</mo></munder>$n";

// right arrow, box on top 
vec         = "<mover accent='true'>$+$n#1$n<mo stretchy='true'>&rarr;</mo>$-$n</mover>$n";

// left arrow, box on top 
vec/l       = "<mover accent='true'>$+$n#1$n<mo stretchy='true'>&larr;</mo>$-$n</mover>$n";

// both arrow, box on top 
vec/lr      = "<mover accent='true'>$+$n#1$n<mo stretchy='true'>&harr;</mo>$-$n</mover>$n";

// harpoon right, box on top 
vec/h    = "<mover accent='true'>$+$n#1$n<mo stretchy='true'>&rharu;</mo>"
           "$-$n</mover>$n";

// right arrow, box on bottom
vec/u       = "<munder accentunder='true'>$+$n#1$n<mo stretchy='true'>&rarr;</mo>$-$n</munder>$n";

// left arrow, box on bottom
vec/u/l     = "<munder accentunder='true'>$+$n#1$n<mo stretchy='true'>&larr;</mo>$-$n</munder>$n";

// both arrow, box on bottom 
vec/u/lr    = "<munder accentunder='true'>$+$n#1$n<mo stretchy='true'>&harr;</mo>$-$n</munder>$n";

// harpoon right, box on bottom
vec/u/h  = "<munder accentunder='true'>$+$n#1$n<mo stretchy='true'>&rharu;</mo>$-$n</munder>$n";

// =====================================================
// Strike Outs
// =====================================================

// ------------------ Translation Warning -------------
// 
// Strike outs are deprecated in MathML, and are likely to
// cause problems in some renderers.

// Mid-line strike-through 
strike/m =  "#1<mpadded width=-100%><mphantom>#1</mphantom></mpadded>"
            "<mo stretchy='true'>&horbar;</mo>";

// Strike-through 
strike =    "#1<mpadded width=-100%><mphantom>#1</mphantom></mpadded>"
            "<mi fontstyle='normal'>X</mi>";

// Strike-through (bottom-left to upper-right)
strike/up = "#1<mpadded width=-100%><mphantom>#1</mphantom></mpadded>"
            "<mo>&rdiag;</mo>";

// Strike-through (top-left to bottom-right)
strike/dn = "#1<mpadded width=-100%><mphantom>#1</mphantom></mpadded>"
            "<mo>&fdiag;</mo>";


// =====================================================
// Arrows with Slots Attached
// =====================================================

// Arrow characters have several common aliases.
// MathML/STIX names are specified here.  In some cases, characters
// are faked or substituted with near equivalents.
//
// longleftarrow, xlarr, LongLeftArrow
// longrightarrow, xrarr, LongRightArrow
// longleftrightarrow, xharr, LongLeftRightArrow
// arrlrsl
// arrsrll
// rlhar, rightleftharpoons, Equilibrium
// lrhar, leftrightharpoons, ReverseEquillibrium

// ------ upper and lower text slots

// Right arrow with upper & lower text slots 
arrow/tb      = "<munderover>$+$n<mo stretchy='true'>&xrarr;</mo>$n#2$n#1$-$n"
	        "</munderover>$n";

// Left arrow with upper & lower text slots 
arrow/l/tb    = "<munderover>$+$n<mo stretchy='true'>&xlarr;</mo>$n#2$n#1$-$n"
 	        "</munderover>$n";

// Double-headed arrow arrow with upper & lower text slots 
arrow/lr/tb   = "<munderover>$+$n<mo stretchy='true'>&xharr;</mo>$n#2$n#1$-$n"
 	        "</munderover>$n";

// Double arrow with upper & lower text slots 
arrow/2/tb    = "<munderover>$+$n<mo stretchy='true'>&rlarr;</mo>$n#2$n#1$-$n"
 	        "</munderover>$n";

// Large over small arrow with upper & lower text slots 
arrow/2/los/tb = "<munderover>$+$n<mo stretchy='true'>&arrlrsl;</mo>$n#2$n#1$-$n"
 	        "</munderover>$n";

// Small over large arrow with upper & lower text slots 
arrow/2/sol/tb = "<munderover>$+$n<mo stretchy='true'>&arrsrll;</mo>$n#2$n#1$-$n"
 	        "</munderover>$n";

// Harpoons with upper & lower text slots 
arrow/2/h/tb  =  "<munderover>$+$n<mo>&rlhar;</mo>$n#2$n#1$-$n</munderover>$n";

// Large over small harpoon with upper & lower text slots 
arrow/2/h/los/tb = "<munderover accentunder='true'>$+$n<mo stretchy='true'>&rharu;</mo>$n"
                "<munder>$+$n<mo stretchy='false'>&lhard;</mo>$n"
                "#2$-$n</munder>$n#1$-$n</munderover>$n";

// Small over large harpoon with upper & lower text slots 
arrow/2/h/sol/tb = "<munderover accentunder='true'>$+$n<mo stretchy='false'>&rharu;</mo>"
                "$n<munder>$+$n<mo stretchy='true'>&lhard;</mo>$n"
                "#2$-$n</munder>$n#1$-$n</munderover>$n";

// ------ upper only text slots

// Right arrow with upper text slots 
arrow         = "<mover>$+$n<mo stretchy='true'>&xrarr;</mo>$n#1$-$n</mover>$n";

// Left arrow with upper text slots 
arrow/l       = "<mover>$+$n<mo stretchy='true'>&xlarr;</mo>$n#1$-$n</mover>$n";

// Double-headed arrow arrow with upper text slots 
arrow/lr      = "<mover>$+$n<mo stretchy='true'>&xharr;</mo>$n#1$-$n</mover>$n";

// Double arrow with upper text slot 
arrow/2       = "<mover>$+$n<mo stretchy='true'>&rlarr;</mo>$n#1$-$n</mover>$n";

// Large over small arrow with upper text slot 
arrow/2/los   = "<mover>$+$n<mo stretchy='true'>&arrlrsl;</mo>$n#1$-$n</mover>$n";

// Small over large arrow with upper text slot 
arrow/2/sol   = "<mover>$+$n<mo stretchy='true'>&arrsrll;</mo>$n#1$-$n</mover>$n";

// Harpoons with upper text slot 
arrow/2/h     = "<mover>$+$n<mo stretchy='true'>&rlhar;</mo>$n#1$-$n</mover>$n";

// Small over large harpoon with upper text slot 
arrow/2/h/sol = "<mover>$+$n<munder accentunder='true'>$+$n<mo stretchy='false'>"
                "&rharu;</mo>$n<mo stretchy='true'>&lhard;</mo>$-$n</munder>$n#1$-$n</mover>$n";

// Large over small harpoon with upper text slot 
arrow/2/h/los = "<mover>$+$n<munder accentunder='true'>$+$n<mo stretchy='true'>&rharu;</mo>$n"
                "<mo stretchy='false'>&lhard;</mo>$-$n</munder>$n#1$-$n</mover>$n";

// ------ lower only text slots

// Right arrow with lower text slots 
arrow/b       = "<mover>$+$n<mo stretchy='true'>&xrarr;</mo>$n#2$-$n</mover>$n";

// Left arrow with lower text slots 
arrow/l/b     = "<mover>$+$n<mo stretchy='true'>&xlarr;</mo>$n#2$-$n</mover>$n";

// Double-headed arrow arrow with lower text slots 
arrow/lr/b    = "<mover>$+$n<mo stretchy='true'>&xharr;</mo>$n#2$-$n</mover>$n";

// Double arrow with lower text slot 
arrow/2/b     = "<munder>$+$n<mo stretchy='true'>&rlarr;</mo>$n#2$-$n</munder>$n";

// Large over small arrow with lower text slot 
arrow/2/los/b = "<munder>$+$n<mo stretchy='true'>&arrlrsl;</mo>$n#2$-$n</munder>$n";

// Small over large arrow with lower text slot 
arrow/2/sol/b = "<munder>$+$n<mo stretchy='true'>&arrsrll;</mo>$n#2$-$n</munder>$n";

// Harpoons with lower text slot 
arrow/2/h/b   = "<munder>$+$n<mo stretchy='true'>&rlhar;</mo>$n#2$-$n</munder>$n";

// Large over small harpoon with lower text slot 
arrow/2/h/los/b = "<munder>$+$n<munder accentunder='true'>$+$n<mo stretchy='true'>&rharu;</mo>$n"
                "<mo stretchy='false'>&lhard;</mo>$-$n</munder>$n#2$-$n</munder>$n";

// Small over large harpoon with lower text slot 
arrow/2/h/sol/b = "<munder>$+$n<munder accentunder='true'>$+$n<mo stretchy='false'>"
                "&rharu;</mo>$n<mo stretchy='true'>&lhard;</mo>$-$n</munder>$n#2$-$n</munder>$n";


// =====================================================
// Embellishment Translations
// =====================================================

// embellishment characters have several common aliases.
// STIX names are specified here.    In some cases, embellishments
// are faked or replaced with near equivalents, since there is no
// exact MathML equivalent
//
// Synonyms:
//
//   ddot, die, Dot
//   dddot, tdot, TripleDot
//   ddddot, DotDot
//   Prime, DoublePrime
//   tprime
//   ` bprime, backprime
//   hat, circ
//   bar, macr
//   leftarrow, larr, LeftArrow
//   rightarrow, rarr, RightArrow
//   leftrightarrow, harr, LeftRightArrow
//   vec (WebEQ specific), rharu, rightharpoonup, RightVector
//   lharu, leftharpoonup
//   rhard, rightharpoondown
//   lhard, leftharpoondown
//   fdiag
//   rdiag


edot        = "<mover accent='true'>$+$n#$n<mo>&dot;</mo>$-$n</mover>$n";
edot/2      = "<mover accent='true'>$+$n#$n<mo>&die;</mo>$-$n</mover>$n";
edot/3      = "<mover accent='true'>$+$n#$n<mo>&tdot;</mo>$-$n</mover>$n";
edot/4      = "<mover accent='true'>$+$n#$n<mo>&DotDot;</mo>$-$n</mover>$n";

edot/u      = "<munder accentunder='true'>$+$n#$n<mo>&dot;</mo>$-$n</mover>$n";
// This should probably use Unicode character 0324, but it has no STIX name
edot/u/2    = "<munder accentunder='true'>$+$n#$n<mo>&die;</mo>$-$n</mover>$n";
edot/u/3    = "<munder accentunder='true'>$+$n#$n<mo>&tdot;</mo>$-$n</mover>$n";
edot/u/4    = "<munder accentunder='true'>$+$n#$n<mo>&DotDot;</mo>$-$n</mover>$n";

eprime      = "<msup>$+$n#$n<mo>&prime;</mo>$-$n</msup>$n";
eprime/2    = "<msup>$+$n#$n<mo>&Prime;</mo>$-$n</msup>$n";
eprime/3    = "<msup>$+$n#$n<mo>&tprime;</mo>$-$n</msup>$n";
eprime/b    = "<mmultiscripts>$+$n#$n<mprescripts/>$n<none/>$n"
              "<mo>&bprime;</mo>$-$n</mmultiscripts>$n";

etilde      = "<mover accent='true'>$+$n#$n<mo>&tilde;</mo>$-$n</munder>$n";
etilde/u    = "<munder accentunder='true'>$+$n#$n<mo>&tilde;</mo>$-$n</munder>$n";

evec        = "<mover accent='true'>$+$n#$n<mo>&rarr;</mo>$-$n</mover>$n";
evec/l      = "<mover accent='true'>$+$n#$n<mo>&larr;</mo>$-$n</mover>$n";
evec/lr     = "<mover accent='true'>$+$n#$n<mo>&harr;</mo>$-$n</mover>$n";
evec/h      = "<mover accent='true'>$+$n#$n<mo>&rharu;</mo>$-$n"
              "</mover>$n";
evec/h/l    = "<mover accent='true'>$+$n#$n<mo>&lharu;</mo>$-$n"
              "</mover>$n";
evec/u      = "<munder accentunder='true'>$+$n#$n<mo>&rarr;</mo>$-$n"
              "</mover>$n";
evec/u/l    = "<mover accent='true'>$+$n#$n<mo>&larr;</mo>$-$n</mover>$n";
evec/u/lr   = "<mover accent='true'>$+$n#$n<mo>&harr;</mo>$-$n</mover>$n";
evec/u/h    = "<mover accent='true'>$+$n#$n<mo>&rhard;</mo>$-$n</mover>$n";
evec/u/h/l  = "<mover accent='true'>$+$n#$n<mo>&lhard;</mo>$-$n</mover>$n";

ehat        = "<mover accent='true'>$+$n#$n<mo>&circ;</mo>$-$n</mover>$n";

eobar       = "<mover accent='true'>$+$n#$n<mo>&macr;</mo>$-$n</mover>$n";
eubar       = "<munder accentunder='true'>$+$n#$n<mo>&lowbar;</mo>$-$n"
              "</munder>$n";

earc        = "<mover accent='true'>$+$n#$n<mo>&frown;</mo>$-$n</mover>$n";
earc/u      = "<munder accentunder='true'>$+$n#$n<mo>&frown;</mo>$-$n</munder>$n";
earc/s      = "<mover accent='true'>$+$n#$n<mo>&smile;</mo>$-$n</mover>$n";
earc/u/s    = "<munder accentunder='true'>$+$n#$n<mo>&smile;</mo>$-$n</munder>$n";

// ------------------ Translation Warning ----------------------
// 
// Overstriking is deprecated in MathML, and is likely to
// cause problems in some renderers.

enot        = "<mpadded width=-100%><mphantom>#</mphantom></mpadded>"
              "<mo>/</mo>";
estrike     = "<mpadded width=-100%><mphantom>#</mphantom></mpadded>"
              "<mo>X</mo>";
estrike/up  = "<mpadded width=-100%><mphantom>#</mphantom></mpadded>"
              "<mo>&rdiag;</mo>";
estrike/dn  = "<mpadded width=-100%><mphantom>#</mphantom></mpadded>"
              "<mo>&fdiag;</mo>";
estrike/m   = "<mpadded width=-100%><mphantom>#</mphantom></mpadded>"
              "<mo>&horbar;</mo>";


// ===================================================================
// Character Translations -- really basic chars are in MATHML.tdl
// ===================================================================
//
// Canonical STIX names are given for character entities whenever possible.
// If a few cases, there is no STIX name, but there are STIX/MathML synonyms,
// and in these cases, one of these is given.  These cases are marked with (???)
// in the description comment.
//
// In some other cases, there is no obvious equivalent STIX/MathML character, 
// but several reasonably close entities, or some other MathML construct, e.g.
// accented characters.  These characters are also marked with (???) and have 
// been handled on a case by case basis.
//
// A small number of characters fit in none of these categories and have been
// allowed to default to the error handling 'defchar' translation rule. 
// Altogether 47 Unicode, and 178 private zone characters fall in this category.

// -------------------------    Greek Characters  --------------------------

char/0x0391 = "<mi>&Agr;</mi>";     // GREEK CAPITAL LETTER ALPHA
char/0x0392 = "<mi>&Bgr;</mi>";     // GREEK CAPITAL LETTER BETA
char/0x0393 = "<mi>&Gamma;</mi>";   // GREEK CAPITAL LETTER GAMMA
char/0x0394 = "<mi>&Delta;</mi>";   // GREEK CAPITAL LETTER DELTA
char/0x0395 = "<mi>&Egr;</mi>";     // GREEK CAPITAL LETTER EPSILON
char/0x0396 = "<mi>&Zgr;</mi>";     // GREEK CAPITAL LETTER ZETA
char/0x0397 = "<mi>&EEgr;</mi>";    // GREEK CAPITAL LETTER ETA
char/0x0398 = "<mi>&Theta;</mi>";   // GREEK CAPITAL LETTER THETA
char/0x0399 = "<mi>&Igr;</mi>";     // GREEK CAPITAL LETTER IOTA
char/0x039A = "<mi>&Kgr;</mi>";     // GREEK CAPITAL LETTER KAPPA
char/0x039B = "<mi>&Lambda;</mi>";  // GREEK CAPITAL LETTER LAMDA
char/0x039C = "<mi>&Mgr;</mi>";     // GREEK CAPITAL LETTER MU
char/0x039D = "<mi>&Ngr;</mi>";     // GREEK CAPITAL LETTER NU
char/0x039E = "<mi>&Xi;</mi>";      // GREEK CAPITAL LETTER XI
char/0x039F = "<mi>&Ogr;</mi>";     // GREEK CAPITAL LETTER OMICRON
char/0x03A0 = "<mi>&Pi;</mi>";      // GREEK CAPITAL LETTER PI
char/0x03A1 = "<mi>&Rgr;</mi>";     // GREEK CAPITAL LETTER RHO
char/0x03A3 = "<mi>&Sigma;</mi>";   // GREEK CAPITAL LETTER SIGMA
char/0x03A4 = "<mi>&Tgr;</mi>";     // GREEK CAPITAL LETTER TAU
char/0x03A5 = "<mi>&Upsi;</mi>";    // GREEK CAPITAL LETTER UPSILON
char/0x03A6 = "<mi>&Phi;</mi>";     // GREEK CAPITAL LETTER PHI
char/0x03A7 = "<mi>&KHgr;</mi>";    // GREEK CAPITAL LETTER CHI
char/0x03A8 = "<mi>&Psi;</mi>";     // GREEK CAPITAL LETTER PSI
char/0x03A9 = "<mi>&Omega;</mi>";   // GREEK CAPITAL LETTER OMEGA

char/0x03B1 = "<mi>&alpha;</mi>";   // GREEK SMALL LETTER ALPHA
char/0x03B2 = "<mi>&beta;</mi>";    // GREEK SMALL LETTER BETA
char/0x03B3 = "<mi>&gamma;</mi>";   // GREEK SMALL LETTER GAMMA
char/0x03B4 = "<mi>&delta;</mi>";   // GREEK SMALL LETTER DELTA
char/0x03B5 = "<mi>&epsiv;</mi>";   // GREEK SMALL LETTER EPSILON
char/0x03B6 = "<mi>&zeta;</mi>";    // GREEK SMALL LETTER ZETA
char/0x03B7 = "<mi>&eta;</mi>";     // GREEK SMALL LETTER ETA
char/0x03B8 = "<mi>&theta;</mi>";   // GREEK SMALL LETTER THETA
char/0x03B9 = "<mi>&iota;</mi>";    // GREEK SMALL LETTER IOTA
char/0x03BA = "<mi>&kappa;</mi>";   // GREEK SMALL LETTER KAPPA
char/0x03BB = "<mi>&lambda;</mi>";  // GREEK SMALL LETTER LAMDA
char/0x03BC = "<mi>&mu;</mi>";      // GREEK SMALL LETTER MU
char/0x03BD = "<mi>&nu;</mi>";      // GREEK SMALL LETTER NU
char/0x03BE = "<mi>&xi;</mi>";      // GREEK SMALL LETTER XI
char/0x03BF = "<mi>&ogr;</mi>";     // GREEK SMALL LETTER OMICRON
char/0x03C0 = "<mi>&pi;</mi>";      // GREEK SMALL LETTER PI
char/0x03C1 = "<mi>&rho;</mi>";     // GREEK SMALL LETTER RHO
char/0x03C2 = "<mi>&sigmav;</mi>";  // GREEK SMALL LETTER FINAL SIGMA
char/0x03C3 = "<mi>&sigma;</mi>";   // GREEK SMALL LETTER SIGMA
char/0x03C4 = "<mi>&tau;</mi>";     // GREEK SMALL LETTER TAU
char/0x03C5 = "<mi>&upsilon;</mi>"; // GREEK SMALL LETTER UPSILON
char/0x03C6 = "<mi>&phi;</mi>";     // GREEK SMALL LETTER PHI
char/0x03C7 = "<mi>&chi;</mi>";     // GREEK SMALL LETTER CHI
char/0x03C8 = "<mi>&psi;</mi>";     // GREEK SMALL LETTER PSI
char/0x03C9 = "<mi>&omega;</mi>";   // GREEK SMALL LETTER OMEGA
char/0x03D1 = "<mi>&thetav;</mi>";  // GREEK THETA SYMBOL
char/0x03D2 = "<mi>&Upsi;</mi>";    // GREEK UPSILON WITH HOOK SYMBOL
char/0x03D5 = "<mi>&phiv;</mi>";    // GREEK PHI SYMBOL
char/0x03D6 = "<mi>&piv;</mi>";     // GREEK PI SYMBOL

char/0x03DC = "<mi>&digamma;</mi>"; // GREEK LETTER DIGAMMA
char/0x03F0 = "<mi>&kappa;</mi>";   // GREEK KAPPA SYMBOL
char/0x03F1 = "<mi>&rho;</mi>";     // GREEK RHO SYMBOL

// -----------   Other More Exotic Character Translations  -----------------------

char/0x00A0 = "<mo>&nbsp;</mo>";                    // NO-BREAK SPACE
char/0x00A1 = "<mo>&iexcl;</mo>";                   // INVERTED EXCLAMATION MARK
char/0x00A2 = "<mo>&cent;</mo>";                    // CENT SIGN
char/0x00A3 = "<mo>&pound;</mo>";                   // POUND SIGN
char/0x00A4 = "<mo>&curren;</mo>";                  // CURRENCY SIGN
char/0x00A5 = "<mo>&yen;</mo>";                     // YEN SIGN
char/0x00A6 = "<mo>&brvbar;</mo>";                  // BROKEN BAR
char/0x00A7 = "<mo>&sect;</mo>";                    // SECTION SIGN
char/0x00A8 = "<mo>&die;</mo>";                     // DIAERESIS
char/0x00A9 = "<mo>&copy;</mo>";                    // COPYRIGHT SIGN
char/0x00AA = "<mo>&ordf;</mo>";                    // FEMININE ORDINAL INDICATOR
char/0x00AB = "<mo>&laquo;</mo>";                   // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
char/0x00AC = "<mo>&not;</mo>";                     // NOT SIGN
char/0x00AD = "<mo>&shy;</mo>";                     // SOFT HYPHEN
char/0x00AE = "<mo>&reg;</mo>";                     // REGISTERED SIGN
char/0x00AF = "<mo>&macr;</mo>";                    // MACRON
char/0x00B0 = "<mo>&deg;</mo>";                     // DEGREE SIGN
char/0x00B1 = "<mo>&plusmn;</mo>";                  // PLUS-MINUS SIGN
char/0x00B2 = "<mo>&sup2;</mo>";                    // SUPERSCRIPT TWO
char/0x00B3 = "<mo>&sup3;</mo>";                    // SUPERSCRIPT THREE
// char/0x00B4 = "";                                // ACUTE ACCENT
char/0x00B5 = "<mo>&micro;</mo>";                   // MICRO SIGN
char/0x00B6 = "<mo>&para;</mo>";                    // PILCROW SIGN
char/0x00B7 = "<mo>&middot;</mo>";                  // MIDDLE DOT
// char/0x00B8 = "";                                // CEDILLA
char/0x00B9 = "<mo>&sup1;</mo>";                    // SUPERSCRIPT ONE
char/0x00BA = "<mo>&ordm;</mo>";                    // MASCULINE ORDINAL INDICATOR
char/0x00BB = "<mo>&raquo;</mo>";                   // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
char/0x00BC = "<mo>&frac14;</mo>";                  // VULGAR FRACTION ONE QUARTER
char/0x00BD = "<mo>&half;</mo>";                    // VULGAR FRACTION ONE HALF
char/0x00BE = "<mo>&frac34;</mo>";                  // VULGAR FRACTION THREE QUARTERS
char/0x00BF = "<mo>&iquest;</mo>";                  // INVERTED QUESTION MARK

// ------------------------   Accented Characters (mostly)   ----------------------
//
// Many of these characters have HTML entity names.  However, since these
// characters are not part of either the STIX or MathML tables, they are
// marked them up as a base character with an accent here.

char/0x00C0 = "<mover accent='true'><mi>A</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER A WITH GRAVE
char/0x00C1 = "<mover accent='true'><mi>A</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER A WITH ACUTE
char/0x00C2 = "<mover accent='true'><mi>A</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER A WITH CIRCUMFLEX
char/0x00C3 = "<mover accent='true'><mi>A</mi><mo>&tilde;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER A WITH TILDE
char/0x00C4 = "<mover accent='true'><mi>A</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER A WITH DIAERESIS
char/0x00C5 = "<mover accent='true'><mi>A</mi><mo>&ring;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER A WITH RING ABOVE
char/0x00C6 = "<mi>&AElig;</mi>";                   // LATIN CAPITAL LIGATURE AE
char/0x00C7 = "<munder accentunder='true'><mi>C</mi><mo>&cedil;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER C WITH CEDILLA
char/0x00C8 = "<mover accent='true'><mi>E</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER E WITH GRAVE
char/0x00C9 = "<mover accent='true'><mi>E</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER E WITH ACUTE
char/0x00CA = "<mover accent='true'><mi>E</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER E WITH CIRCUMFLEX
char/0x00CB = "<mover accent='true'><mi>E</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER E WITH DIAERESIS
char/0x00CC = "<mover accent='true'><mi>I</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER I WITH GRAVE
char/0x00CD = "<mover accent='true'><mi>I</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER I WITH ACUTE
char/0x00CE = "<mover accent='true'><mi>I</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER I WITH CIRCUMFLEX
char/0x00CF = "<mover accent='true'><mi>I</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER I WITH DIERESIS
char/0x00D0 = "<mi>&ETH;</mi>";                     // LATIN CAPITAL LETTER ETH
char/0x00D1 = "<mover accent='true'><mi>N</mi><mo>&tilde;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER N WITH TILDE
char/0x00D2 = "<mover accent='true'><mi>O</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER O WITH GRAVE
char/0x00D3 = "<mover accent='true'><mi>O</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER O WITH ACUTE
char/0x00D4 = "<mover accent='true'><mi>O</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER O WITH CIRCUMFLEX
char/0x00D5 = "<mover accent='true'><mi>O</mi><mo>&tilde;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER O WITH TILDE
char/0x00D6 = "<mover accent='true'><mi>O</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER O WITH DIAERESIS
char/0x00D7 = "<mo>&times;</mo>";                   // MULTIPLICATION SIGN
char/0x00D8 = "<mo>&Oslash;</mo>";                  // LATIN CAPITAL LETTER O WITH STROKE
char/0x00D9 = "<mover accent='true'><mi>U</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER U WITH GRAVE
char/0x00DA = "<mover accent='true'><mi>U</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER U WITH ACUTE
char/0x00DB = "<mover accent='true'><mi>U</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER U WITH CIRCUMFLEX
char/0x00DC = "<mover accent='true'><mi>U</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER U WITH DIAERESIS
char/0x00DD = "<mover accent='true'><mi>Y</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN CAPITAL LETTER Y WITH ACUTE
char/0x00DE = "<mo>&THORN;</mo>";                   // LATIN CAPITAL LETTER THORN
char/0x00DF = "<mo>&szlig;</mo>";                   // LATIN SMALL LETTER SHARP S
char/0x00E0 = "<mover accent='true'><mi>a</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN SMALL LETTER A WITH GRAVE
char/0x00E1 = "<mover accent='true'><mi>a</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN SMALL LETTER A WITH ACUTE
char/0x00E2 = "<mover accent='true'><mi>a</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN SMALL LETTER A WITH CIRCUMFLEX
char/0x00E3 = "<mover accent='true'><mi>a</mi><mo>&tilde;</mo></mover>$n";
                                                    // LATIN SMALL LETTER A WITH TILDE
char/0x00E4 = "<mover accent='true'><mi>a</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN SMALL LETTER A WITH DIAERESIS
char/0x00E5 = "<mover accent='true'><mi>a</mi><mo>&ring;</mo></mover>$n";
                                                    // LATIN SMALL LETTER A WITH RING ABOVE
char/0x00E6 = "<mi>&aelig;</mi>";                   // LATIN SMALL LIGATURE AE
char/0x00E7 = "<mi>&ccedil;</mi>";                  // LATIN SMALL LETTER C WITH CEDILLA
char/0x00E8 = "<mover accent='true'><mi>e</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN SMALL LETTER E WITH GRAVE
char/0x00E9 = "<mover accent='true'><mi>e</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN SMALL LETTER E WITH ACUTE
char/0x00EA = "<mover accent='true'><mi>e</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN SMALL LETTER E WITH CIRCUMFLEX
char/0x00EB = "<mover accent='true'><mi>e</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN SMALL LETTER E WITH DIAERESIS
char/0x00EC = "<mover accent='true'><mi>i</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN SMALL LETTER I WITH GRAVE
char/0x00ED = "<mover accent='true'><mi>i</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN SMALL LETTER I WITH ACUTE
char/0x00EE = "<mover accent='true'><mi>i</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN SMALL LETTER I WITH CIRCUMFLEX
char/0x00EF = "<mover accent='true'><mi>i</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN SMALL LETTER I WITH DIAERESIS
char/0x00F0 = "<mi>&eth;</mi>";                     // LATIN SMALL LETTER ETH
char/0x00F1 = "<mo>&ntilde;</mo>";                  // LATIN SMALL LETTER N WITH TILDE
char/0x00F2 = "<mover accent='true'><mi>o</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN SMALL LETTER O WITH GRAVE
char/0x00F3 = "<mover accent='true'><mi>o</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN SMALL LETTER O WITH ACUTE
char/0x00F4 = "<mover accent='true'><mi>o</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN SMALL LETTER O WITH CIRCUMFLEX
char/0x00F5 = "<mover accent='true'><mi>o</mi><mo>&tilde;</mo></mover>$n";
                                                    // LATIN SMALL LETTER O WITH TILDE
char/0x00F6 = "<mover accent='true'><mi>o</mi><mo>&die</mo></mover>$n";
                                                    // LATIN SMALL LETTER O WITH DIAERESIS
char/0x00F7 = "<mo>&divide;</mo>";                  // DIVISION SIGN
char/0x00F8 = "<mo>&oslash;</mo>";                  // LATIN SMALL LETTER O WITH STROKE
char/0x00F9 = "<mover accent='true'><mi>u</mi><mo>&grave;</mo></mover>$n";
                                                    // LATIN SMALL LETTER U WITH GRAVE
char/0x00FA = "<mover accent='true'><mi>u</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN SMALL LETTER U WITH ACUTE
char/0x00FB = "<mover accent='true'><mi>u</mi><mo>&circ;</mo></mover>$n";
                                                    // LATIN SMALL LETTER U WITH CIRCUMFLEX
char/0x00FC = "<mover accent='true'><mi>u</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN SMALL LETTER U WITH DIAERESIS
char/0x00FD = "<mover accent='true'><mi>y</mi><mo>&acute;</mo></mover>$n";
                                                    // LATIN SMALL LETTER Y WITH ACUTE
char/0x00FE = "<mo>&thorn;</mo>";                   // LATIN SMALL LETTER THORN
char/0x00FF = "<mover accent='true'><mi>y</mi><mo>&die;</mo></mover>$n";
                                                    // LATIN SMALL LETTER Y WITH DIAERESIS
char/0x0131 = "<mo>&imath;</mo>";                   // LATIN SMALL LETTER DOTLESS I
char/0x0152 = "<mo>&OElig;</mo>";                   // LATIN CAPITAL LIGATURE OE
// char/0x0153 = "";                                // LATIN SMALL LIGATURE OE
// char/0x0160 = "";                                // LATIN CAPITAL LETTER S WITH CARON
char/0x0161 = "<mo>&scaron;</mo>";                  // LATIN SMALL LETTER S WITH CARON
// char/0x0178 = "";                                // LATIN CAPITAL LETTER Y WITH DIAERESIS
// char/0x0192 = "";                                // LATIN SMALL LETTER F WITH HOOK
// char/0x019A = "";                                // LATIN SMALL LETTER L WITH BAR
// char/0x019B = ""                                 // LATIN SMALL LETTER LAMBDA WITH STROKE
// char/0x02BE = "";                                // MODIFIER LETTER RIGHT HALF RING
// char/0x02BF = "";                                // MODIFIER LETTER LEFT HALF RING
// char/0x02C6 = "";                                // MODIFIER LETTER CIRCUMFLEX ACCENT
// char/0x02C7 = "";                                // CARON
// char/0x02D8 = "";                                // BREVE
// char/0x02D9 = "";                                // DOT ABOVE
// char/0x02DA = "";                                // RING ABOVE
// char/0x02DB = "";                                // OGONEK
// char/0x02DC = "";                                // SMALL TILDE
// char/0x02DD = "";                                // DOUBLE ACUTE ACCENT
char/0x0300 = "<mo>&grave;</mo>";                   // COMBINING GRAVE ACCENT
char/0x0302 = "<mo>&circ;</mo>";                    // COMBINING CIRCUMFLEX ACCENT
char/0x0303 = "<mo>&tilde;</mo>";                   // COMBINING TILDE
char/0x0307 = "<mo>&dot;</mo>";                     // COMBINING DOT ABOVE
char/0x0323 = "<mo>&dundot;</mo>";                  // COMBINING DOT BELOW (???)
char/0x0327 = "<mo>&cedil;</mo>";                   // COMBINING CEDILLA
char/0x0331 = "<mo>&underbar;</mo>";                // COMBINING MACRON BELOW (???)
// char/0x0338 = "";                                // COMBINING LONG SOLIDUS OVERLAY

// --------------------    Some Punctuation   ---------------------------
                            
char/0x2013 = "<mo>&ndash;</mo>";                   // EN DASH
char/0x2014 = "<mo>&mdash;</mo>";                   // EM DASH
char/0x2018 = "<mo>&lsquo;</mo>";                   // LEFT SINGLE QUOTATION MARK
char/0x2019 = "<mo>&rsquo;</mo>";                   // RIGHT SINGLE QUOTATION MARK
char/0x201A = "<mo>&lsquor;</mo>";                  // SINGLE LOW-9 QUOTATION MARK
char/0x201C = "<mo>&ldquo;</mo>";                   // LEFT DOUBLE QUOTATION MARK
char/0x201D = "<mo>&rdquo;</mo>";                   // RIGHT DOUBLE QUOTATION MARK
char/0x201E = "<mo>&ldquor;</mo>";                  // DOUBLE LOW-9 QUOTATION MARK
char/0x2020 = "<mo>&dagger;</mo>";                  // DAGGER == \dag in math, \dagger in text
char/0x2021 = "<mo>&Dagger;</mo>";                  // DOUBLE DAGGER
char/0x2022 = "<mo>&bull;</mo>";                    // BULLET
char/0x2026 = "<mo>&hellip;</mo>";                  // HORIZONTAL ELLIPSIS
char/0x2030 = "<mo>&permil;</mo>";                  // PER MILLE SIGN
char/0x2032 = "<mo>&prime;</mo>";                   // PRIME
char/0x2033 = "<mo>&Prime;</mo>";                   // DOUBLE PRIME
char/0x2035 = "<mo>&bprime;</mo>";                  // REVERSED PRIME
char/0x2036 = "<mo>&bPrime;</mo>";                  // REVERSED DOUBLE PRIME
char/0x2039 = "<mo>&lsaquo;</mo>";                  // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
char/0x203A = "<mo>&rsaquo;</mo>";                  // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
// char/0x2040 = "";                                // CHARACTER TIE
// char/0x2044 = "";                                // FRACTION SLASH
char/0x20AC = "<mo>&$#8364;</mo>";                  // Euro symbol
// char/0x20D0 = "";                                // COMBINING LEFT HARPOON ABOVE
// char/0x20D1 = "";                                // COMBINING RIGHT HARPOON ABOVE
// char/0x20D6 = "";                                // COMBINING LEFT ARROW ABOVE
// char/0x20D7 = "";                                // COMBINING RIGHT ARROW ABOVE
char/0x20DB = "<mo>&tdot;</mo>";                    // COMBINING THREE DOTS ABOVE
// char/0x20E1 = ""                                 // COMBINING LEFT RIGHT ARROW ABOVE

// -------   Unicode Script, Fraktur, Blackboard Bold, etc.  ---------------
                            
char/0x2102 = "<mi>&Copf;</mi>";                    // DOUBLE-STRUCK CAPITAL C
// char/0x2107 = "";                                // EULER CONSTANT
char/0x210A = "<mi>&gscr;</mi>";                    // SCRIPT SMALL G
char/0x210B = "<mi>&Hscr;</mi>";                    // SCRIPT CAPITAL H == \cal in latex
char/0x210C = "<mi>&Hfr;</mi>";                     // BLACK-LETTER CAPITAL H
char/0x210D = "<mi>&Hopf;</mi>";                    // DOUBLE-STRUCK CAPITAL H
// char/0x210E = "";                                // PLANCK CONSTANT
char/0x210F = "<mi>&plankv;</mi>";                  // PLANCK CONSTANT OVER TWO PI
char/0x2110 = "<mi>&Iscr;</mi>";                    // SCRIPT CAPITAL I
char/0x2111 = "<mi>&Ifr;</mi>";                     // BLACK-LETTER CAPITAL I
char/0x2112 = "<mi>&Lscr;</mi>";                    // SCRIPT CAPITAL L
char/0x2113 = "<mi>&lscr;</mi>";                    // SCRIPT SMALL L
char/0x2115 = "<mi>&Nopf;</mi>";                    // DOUBLE-STRUCK CAPITAL N
char/0x2118 = "<mi>&weierp;</mi>";                  // SCRIPT CAPITAL P (Weierstrass P)
char/0x2119 = "<mi>&Popf;</mi>";                    // DOUBLE-STRUCK CAPITAL P
char/0x211A = "<mi>&Qopf;</mi>";                    // DOUBLE-STRUCK CAPITAL Q
char/0x211B = "<mi>&Rscr;</mi>";                    // SCRIPT CAPITAL R
char/0x211C = "<mi>&Rfr;</mi>";                     // BLACK-LETTER CAPITAL R
char/0x211D = "<mi>&Ropf;</mi>";                    // DOUBLE-STRUCK CAPITAL R
char/0x2122 = "<mi>&trade;</mi>";                   // TRADE MARK SIGN
char/0x2124 = "<mi>&Zopf;</mi>";                    // DOUBLE-STRUCK CAPITAL Z
// char/0x2125 = "";                                // OUNCE SIGN
char/0x2126 = "<mi>&ohm;</mi>";                     // OHM SIGN
char/0x2127 = "<mi>&mho;</mi>";                     // INVERTED OHM SIGN
char/0x2128 = "<mi>&Zfr;</mi>";                     // BLACK-LETTER CAPITAL Z
char/0x212C = "<mi>&Bscr;</mi>";                    // SCRIPT CAPITAL B
char/0x212D = "<mi>&Cfr;</mi>";                     // BLACK-LETTER CAPITAL C
char/0x2130 = "<mi>&Escr;</mi>";                    // SCRIPT CAPITAL E
char/0x2131 = "<mi>&Fscr;</mi>";                    // SCRIPT CAPITAL F
// char/0x2132 = "";                                // TURNED CAPITAL F
char/0x2133 = "<mi>&Mscr;</mi>";                    // SCRIPT CAPITAL M
char/0x2135 = "<mi>&aleph;</mi>";                   // ALEF SYMBOL
char/0x2136 = "<mi>&beth;</mi>";                    // BET SYMBOL
char/0x2137 = "<mi>&gimel;</mi>";                   // GIMEL SYMBOL
char/0x2138 = "<mi>&daleth;</mi>";                  // DALET SYMBOL

// --------------------------------  Arrows  ---------------------------------
                            
char/0x2190 = "<mo>&larr;</mo>";                    // LEFTWARDS ARROW
char/0x2191 = "<mo>&uarr;</mo>";                    // UPWARDS ARROW
char/0x2192 = "<mo>&rarr;</mo>";                    // RIGHTWARDS ARROW
char/0x2193 = "<mo>&darr;</mo>";                    // DOWNWARDS ARROW
char/0x2194 = "<mo>&harr;</mo>";                    // LEFT RIGHT ARROW
char/0x2195 = "<mo>&varr;</mo>";                    // UP DOWN ARROW
char/0x2196 = "<mo>&nwarr;</mo>";                   // NORTH WEST ARROW
char/0x2197 = "<mo>&nearr;</mo>";                   // NORTH EAST ARROW
char/0x2198 = "<mo>&searr;</mo>";                   // SOUTH EAST ARROW
char/0x2199 = "<mo>&swarr;</mo>";                   // SOUTH WEST ARROW
char/0x219A = "<mo>&nlarr;</mo>";                  // LEFTWARDS ARROW WITH STROKE
char/0x219B = "<mo>&nrarr;</mo>";                   // RIGHTWARDS ARROW WITH STROKE
char/0x219C = "<mo>&larrw;</mo>";                   // LEFTWARDS WAVE ARROW
char/0x219D = "<mo>&rarrw;</mo>";                   // RIGHTWARDS WAVE ARROW
char/0x219E = "<mo>&Larr;</mo>";                    // LEFTWARDS TWO HEADED ARROW
char/0x219F = "<mo>&Uarr;</mo>";                    // UPWARDS TWO HEADED ARROW
char/0x21A0 = "<mo>&Rarr;</mo>";                    // RIGHTWARDS TWO HEADED ARROW
char/0x21A1 = "<mo>&Darr;</mo>";                    // DOWNWARDS TWO HEADED ARROW
char/0x21A2 = "<mo>&larrtl;</mo>";                  // LEFTWARDS ARROW WITH TAIL
char/0x21A3 = "<mo>&rarrtl;</mo>";                  // RIGHTWARDS ARROW WITH TAIL
char/0x21A4 = "<mo>&mapstoleft;</mo>";              // LEFTWARDS ARROW FROM BAR
char/0x21A5 = "<mo>&mapstoup;</mo>";                // UPWARDS ARROW FROM BAR
char/0x21A6 = "<mo>&map;</mo>";                     // RIGHTWARDS ARROW FROM BAR
char/0x21A7 = "<mo>&mapstodown;</mo>";              // DOWNWARDS ARROW FROM BAR
char/0x21A8 = "<mo>&varrb;</mo>";                   // UP DOWN ARROW WITH BASE (???)
char/0x21A9 = "<mo>&larrhk;</mo>";                  // LEFTWARDS ARROW WITH HOOK
char/0x21AA = "<mo>&rarrhk;</mo>";                  // RIGHTWARDS ARROW WITH HOOK
char/0x21AB = "<mo>&larrlp;</mo>";                  // LEFTWARDS ARROW WITH LOOP
char/0x21AC = "<mo>&rarrlp;</mo>";                  // RIGHTWARDS ARROW WITH LOOP
char/0x21AD = "<mo>&harrw;</mo>";                   // LEFT RIGHT WAVE ARROW
char/0x21AE = "<mo>&nharr;</mo>";                   // LEFT RIGHT ARROW WITH STROKE
// char/0x21AF = "";                                // DOWNWARDS ZIGZAG ARROW
char/0x21B0 = "<mo>&lsh;</mo>";                     // UPWARDS ARROW WITH TIP RIGHTWARDS
char/0x21B2 = "<mo>&ldsh;</mo>";                    // DOWNWARDS ARROW WITH TIP RIGHTWARDS
// char/0x21B4 = "";                                // RIGHTWARDS ARROW WITH CORNER DOWNWARDS
char/0x21B5 = "<mi>&ReturnIndicator;</mi>";         // DOWNWARDS ARROW WITH CORNER LEFTWARDS (???)
char/0x21B6 = "<mo>&cularr;</mo>";                  // ANTICLOCKWISE TOP SEMICIRCLE ARROW
char/0x21B7 = "<mo>&curarr;</mo>";                  // CLOCKWISE TOP SEMICIRCLE ARROW
// char/0x21BA = "";                                // ANTICLOCKWISE OPEN CIRCLE ARROW
// char/0x21BB = "";                                // CLOCKWISE OPEN CIRCLE ARROW
char/0x21BC = "<mo>&lharu;</mo>";                   // LEFTWARDS HARPOON WITH BARB UPWARDS
char/0x21BD = "<mo>&lhard;</mo>";                   // LEFTWARDS HARPOON WITH BARB DOWNWARDS
char/0x21BE = "<mo>&uharr;</mo>";                   // UPWARDS HARPOON WITH BARB RIGHTWARDS
char/0x21BF = "<mo>&uharl;</mo>";                   // UPWARDS HARPOON WITH BARB LEFTWARDS
char/0x21C0 = "<mo>&rharu;</mo>";                   // RIGHTWARDS HARPOON WITH BARB UPWARDS
char/0x21C1 = "<mo>&rhard;</mo>";                   // RIGHTWARDS HARPOON WITH BARB DOWNWARDS
char/0x21C2 = "<mo>&dharr;</mo>";                   // DOWNWARDS HARPOON WITH BARB RIGHTWARDS
char/0x21C3 = "<mo>&dharl;</mo>";                   // DOWNWARDS HARPOON WITH BARB LEFTWARDS
char/0x21C4 = "<mo>&rlarr;</mo>";                   // RIGHTWARDS ARROW OVER LEFTWARDS ARROW
char/0x21C5 = "<mo>&udarr;</mo>";                   // UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW
char/0x21C6 = "<mo>&lrarr;</mo>";                   // LEFTWARDS ARROW OVER RIGHTWARDS ARROW
char/0x21C7 = "<mo>&llarr;</mo>";                   // LEFTWARDS PAIRED ARROWS
char/0x21C8 = "<mo>&uuarr;</mo>";                   // UPWARDS PAIRED ARROWS
char/0x21C9 = "<mo>&rrarr;</mo>";                   // RIGHTWARDS PAIRED ARROWS
char/0x21CA = "<mo>&ddarr;</mo>";                   // DOWNWARDS PAIRED ARROWS
char/0x21CB = "<mo>&lrhar;</mo>";                   // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
char/0x21CC = "<mo>&rlhar;</mo>";                   // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
char/0x21CD = "<mo>&nlArr;</mo>";                   // LEFTWARDS DOUBLE ARROW WITH STROKE
char/0x21CE = "<mo>&nhArr;</mo>";                   // LEFT RIGHT DOUBLE ARROW WITH STROKE
char/0x21CF = "<mo>&nrArr;</mo>";                   // RIGHTWARDS DOUBLE ARROW WITH STROKE
char/0x21D0 = "<mo>&lArr;</mo>";                    // LEFTWARDS DOUBLE ARROW
char/0x21D1 = "<mo>&uArr;</mo>";                    // UPWARDS DOUBLE ARROW
char/0x21D2 = "<mo>&rArr;</mo>";                    // RIGHTWARDS DOUBLE ARROW
char/0x21D3 = "<mo>&dArr;</mo>";                    // DOWNWARDS DOUBLE ARROW
char/0x21D4 = "<mo>&hArr;</mo>";                    // LEFT RIGHT DOUBLE ARROW
char/0x21D5 = "<mo>&vArr;</mo>";                    // UP DOWN DOUBLE ARROW
char/0x21D6 = "<mo>&nwArr;</mo>";                   // NORTH WEST DOUBLE ARROW
char/0x21D7 = "<mo>&neArr;</mo>";                   // NORTH EAST DOUBLE ARROW
char/0x21D8 = "<mo>&seArr;</mo>";                   // SOUTH EAST DOUBLE ARROW
char/0x21D9 = "<mo>&swArr;</mo>";                   // SOUTH WEST DOUBLE ARROW
char/0x21DA = "<mo>&lAarr;</mo>";                   // LEFTWARDS TRIPLE ARROW
char/0x21DB = "<mo>&rAarr;</mo>";                   // RIGHTWARDS TRIPLE ARROW
char/0x21DC = "<mo>&dziglarr;</mo>";                // LEFTWARDS SQUIGGLE ARROW
char/0x21DD = "<mo>&dzigrarr;</mo>";                // RIGHTWARDS SQUIGGLE ARROW
char/0x21E0 = "<mo>&lBarr;</mo>";                   // LEFTWARDS DASHED ARROW (???)
// char/0x21E1 = "";                                // UPWARDS DASHED ARROW
char/0x21E2 = "<mo>&rBarr;</mo>";                   // RIGHTWARDS DASHED ARROW (???)
// char/0x21E3 = "";                                // DOWNWARDS DASHED ARROW
char/0x21E4 = "<mo>&LeftArrowBar;</mo>";            // LEFTWARDS ARROW TO BAR (???)
char/0x21E5 = "<mo>&RightArrowBar;</mo>";           // RIGHTWARDS ARROW TO BAR (???)

// -----------------------  Miscellaneous Operators ----------------------------
                            
char/0x2200 = "<mo>&forall;</mo>";                  // FOR ALL
char/0x2201 = "<mo>&comp;</mo>";                    // COMPLEMENT
char/0x2202 = "<mo>&part;</mo>";                    // PARTIAL DIFFERENTIAL
char/0x2203 = "<mo>&exist;</mo>";                   // THERE EXISTS
char/0x2204 = "<mo>&nexist;</mo>";                  // THERE DOES NOT EXIST
char/0x2205 = "<mo>&emptyv;</mo>";                  // EMPTY SET
// char/0x2206 = "";                                // Increment
char/0x2207 = "<mo>&nabla;</mo>";                   // Gradient (nabla)
char/0x2208 = "<mo>&isinv;</mo>";                   // ELEMENT OF
char/0x2209 = "<mo>&notin;</mo>";                   // NOT AN ELEMENT OF
char/0x220A = "<mo>&isin;</mo>";                    // Small element of
char/0x220B = "<mo>&niv;</mo>";                     // Contains as member
char/0x220C = "<mo>&notniva;</mo>";                 // Does not contain as member
char/0x220D = "<mo>&ni;</mo>";                      // SMALL CONTAINS AS MEMBER
char/0x220F = "<mo>&prod;</mo>";                    // N-ARY PRODUCT
char/0x2210 = "<mo>&coprod;</mo>";                  // N-ARY COPRODUCT
char/0x2211 = "<mo>&sum;</mo>";                     // N-ARY SUMMATION
char/0x2212 = "<mo>-</mo>";                         // MINUS SIGN
char/0x2213 = "<mo>&mnplus;</mo>";                  // MINUS-OR-PLUS SIGN
char/0x2214 = "<mo>&plusdo;</mo>";                  // DOT PLUS
char/0x2215 = "<mo>/</mo>";                         // Division slash (???)
char/0x2216 = "<mo>&setmn;</mo>";                   // Set minus
char/0x2217 = "<mo>&midast;</mo>";                  // Asterisk operator
char/0x2218 = "<mo>&compfn;</mo>";                  // Composition
char/0x2219 = "<mo>&bullet;</mo>";                  // Bullet operator (???)
char/0x221A = "<mo>&radic;</mo>";                   // Radical sign
// char/0x221B = "";                                // Cube root
// char/0x221C = "";                                // Fourth root
char/0x221D = "<mo>&prop;</mo>";                    // PROPORTIONAL TO
char/0x221E = "<mo>&infin;</mo>";                   // INFINITY
char/0x221F = "<mo>&angrt;</mo>";                   // RIGHT ANGLE
char/0x2220 = "<mo>&ang;</mo>";                     // ANGLE
char/0x2221 = "<mo>&angmsd;</mo>";                  // MEASURED ANGLE
char/0x2222 = "<mo>&angsph;</mo>";                  // SPHERICAL ANGLE
char/0x2223 = "<mo>&mid;</mo>";                     // MID
char/0x2224 = "<mo>&nmid;</mo>";                    // DOES NOT DIVIDE
char/0x2225 = "<mo>&par;</mo>";                     // PARALLEL TO
char/0x2226 = "<mo>&npar;</mo>";                    // NOT PARALLEL TO
char/0x2227 = "<mo>&and;</mo>";                     // LOGICAL AND
char/0x2228 = "<mo>&or;</mo>";                      // LOGICAL OR
char/0x2229 = "<mo>&cap;</mo>";                     // INTERSECTION
char/0x222A = "<mo>&cup;</mo>";                     // UNION
char/0x222B = "<mo>&int;</mo>";                     // INTEGRAL
char/0x222C = "<mo>&Int;</mo>";                     // DOUBLE INTEGRAL
char/0x222D = "<mo>&tint;</mo>";                    // TRIPLE INTEGRAL
char/0x222E = "<mo>&conint;</mo>";                  // CONTOUR INTEGRAL
char/0x222F = "<mo>&Conint;</mo>";                  // SURFACE INTEGRAL
char/0x2230 = "<mo>&Cconint;</mo>";                 // VOLUME INTEGRAL
char/0x2231 = "<mo>&cwint;</mo>";                   // CLOCKWISE INTEGRAL
char/0x2232 = "<mo>&cwconint;</mo>";                // CLOCKWISE CONTOUR INTEGRAL
char/0x2233 = "<mo>&awconint;</mo>";                // ANTICLOCKWISE CONTOUR INTEGRAL
char/0x2234 = "<mo>&there4;</mo>";                  // THEREFORE
char/0x2235 = "<mo>&becaus;</mo>";                  // BECAUSE
char/0x2236 = "<mo>&ratio;</mo>";                   // RATIO
char/0x2237 = "<mo>&Colon;</mo>";                   // PROPORTION
char/0x2238 = "<mo>&minusd;</mo>";                  // DOT MINUS
char/0x2239 = "<mo>&excess;</mo>";                  // EXCESS
char/0x223A = "<mo>&mDDot;</mo>";                   // GEOMETRIC PROPORTION
char/0x223B = "<mo>&homtht;</mo>";                  // HOMOTHETIC
char/0x223C = "<mo>&sim;</mo>";                     // TILDE OPERATOR
char/0x223D = "<mo>&bsim;</mo>";                    // REVERSED TILDE
char/0x223E = "<mo>&mstpos;</mo>";                  // INVERTED LAZY S
// char/0x223F = "";                                // SINE WAVE
char/0x2240 = "<mo>&wreath;</mo>";                  // WREATH PRODUCT
char/0x2241 = "<mo>&nsim;</mo>";                    // NOT TILDE
char/0x2242 = "<mo>&esim;</mo>";                    // MINUS TILDE
char/0x2243 = "<mo>&sime;</mo>";                    // ASYMPTOTICALLY EQUAL TO
char/0x2244 = "<mo>&nsime;</mo>";                   // NOT ASYMPTOTICALLY EQUAL TO
char/0x2245 = "<mo>&cong;</mo>";                    // APPROXIMATELY EQUAL TO
char/0x2247 = "<mo>&ncong;</mo>";                   // NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO
char/0x2248 = "<mo>&ap;</mo>";                      // ALMOST EQUAL TO
char/0x2249 = "<mo>&nap;</mo>";                     // NOT ALMOST EQUAL TO
char/0x224A = "<mo>&ape;</mo>";                     // ALMOST EQUAL OR EQUAL TO
char/0x224B = "<mo>&apid;</mo>";                    // TRIPLE TILDE
// char/0x224C = "";                                // ALL EQUAL TO
char/0x224D = "<mo>&asymp;</mo>";                   // EQUIVALENT TO
char/0x224E = "<mo>&bump;</mo>";                    // GEOMETRICALLY EQUIVALENT TO
char/0x224F = "<mo>&bumpe;</mo>";                   // DIFFERENCE BETWEEN
char/0x2250 = "<mo>&esdot;</mo>";                   // APPROACHES THE LIMIT
char/0x2251 = "<mo>&eDot;</mo>";                    // GEOMETRICALLY EQUAL TO
char/0x2252 = "<mo>&efDot;</mo>";                   // APPROXIMATELY EQUAL TO OR THE IMAGE OF
char/0x2253 = "<mo>&erDot;</mo>";                   // IMAGE OF OR APPROXIMATELY EQUAL TO
char/0x2254 = "<mo>&colone;</mo>";                  // COLON EQUALS
char/0x2255 = "<mo>&ecolon;</mo>";                  // EQUALS COLON
char/0x2256 = "<mo>&ecir;</mo>";                    // RING IN EQUAL TO
char/0x2257 = "<mo>&cire;</mo>";                    // RING EQUAL TO
char/0x2258 = "<mo>&arceq;</mo>";                   // CORRESPONDS TO
char/0x2259 = "<mo>&wedgeq;</mo>";                  // ESTIMATES
char/0x225A = "<mo>&veeeq;</mo>";                   // EQUIANGULAR TO
char/0x225C = "<mo>&trie;</mo>";                    // DELTA EQUAL TO
char/0x225D = "<mo>&eqdef;</mo>";                   // EQUAL TO BY DEFINITION
char/0x225E = "<mo>&measeq;</mo>";                  // MEASURED BY
char/0x225F = "<mo>&equest;</mo>";                  // QUESTIONED EQUAL TO
char/0x2260 = "<mo>&ne;</mo>";                      // NOT EQUAL TO
char/0x2261 = "<mo>&equiv;</mo>";                   // IDENTICAL TO
char/0x2262 = "<mo>&nequiv;</mo>";                  // NOT IDENTICAL TO
char/0x2263 = "<mo>&Equiv;</mo>";                   // STRICTLY EQUIVALENT TO
char/0x2264 = "<mo>&le;</mo>";                      // LESS-THAN OR EQUAL TO
char/0x2265 = "<mo>&ge;</mo>";                      // GREATER-THAN OR EQUAL TO
char/0x2266 = "<mo>&lE;</mo>";                      // LESS-THAN OVER EQUAL TO
char/0x2267 = "<mo>&gE;</mo>";                      // GREATER-THAN OVER EQUAL TO
char/0x2268 = "<mo>&lnE;</mo>";                     // LESS-THAN BUT NOT EQUAL TO
char/0x2269 = "<mo>&gnE;</mo>";                     // GREATER-THAN BUT NOT EQUAL TO
char/0x226A = "<mo>&Lt;</mo>";                      // MUCH LESS-THAN  (???)
char/0x226B = "<mo>&Gt;</mo>";                      // MUCH GREATER-THAN  (???)
char/0x226C = "<mo>&twixt;</mo>";                   // BETWEEN
char/0x226D = "<mo>&nasymp;</mo>";                  // NOT EQUIVALENT TO
char/0x226E = "<mo>&nlt;</mo>";                     // NOT LESS-THAN
char/0x226F = "<mo>&ngt;</mo>";                     // NOT GREATER-THAN
char/0x2270 = "<mo>&nles;</mo>";                    // NEITHER LESS-THAN NOR EQUAL TO
char/0x2271 = "<mo>&nges;</mo>";                    // NEITHER GREATER-THAN NOR EQUAL TO
char/0x2272 = "<mo>&lsim;</mo>";                    // LESS-THAN OR EQUIVALENT TO
char/0x2273 = "<mo>&gsim;</mo>";                    // GREATER-THAN OR EQUIVALENT TO
char/0x2274 = "<mo>&nlsim;</mo>";                   // NEITHER LESS-THAN NOR EQUIVALENT TO
char/0x2275 = "<mo>&ngsim;</mo>";                   // NEITHER GREATER-THAN NOR EQUIVALENT TO
char/0x2276 = "<mo>&lg;</mo>";                      // LESS-THAN OR GREATER-THAN
char/0x2277 = "<mo>&gl;</mo>";                      // GREATER-THAN OR LESS-THAN
char/0x227A = "<mo>&pr;</mo>";                      // PRECEDES
char/0x227B = "<mo>&sc;</mo>";                      // SUCCEEDS
char/0x227C = "<mo>&prcue;</mo>";                   // PRECEDES OR EQUAL TO
char/0x227D = "<mo>&sccue;</mo>";                   // SUCCEEDS OR EQUAL TO
char/0x227E = "<mo>&prsim;</mo>";                   // PRECEDES OR EQUIVALENT TO
char/0x227F = "<mo>&scsim;</mo>";                   // SUCCEEDS OR EQUIVALENT TO
char/0x2280 = "<mo>&npr;</mo>";                     // DOES NOT PRECEDE
char/0x2281 = "<mo>&nsc;</mo>";                     // DOES NOT SUCCEED
char/0x2282 = "<mo>&sub;</mo>";                     // SUBSET OF
char/0x2283 = "<mo>&sup;</mo>";                     // SUPERSET OF<mo>
char/0x2284 = "<mo>&vnsub;</mo>";                   // NOT A SUBSET OF
char/0x2285 = "<mo>&vnsup;</mo>";                   // NOT A SUPERSET OF
char/0x2286 = "<mo>&sube;</mo>";                    // SUBSET OF OR EQUAL TO
char/0x2287 = "<mo>&supe;</mo>";                    // SUPERSET OF OR EQUAL TO
char/0x2288 = "<mo>&nsube;</mo>";                   // NEITHER A SUBSET OF NOR EQUAL TO  (???)
char/0x2289 = "<mo>&nsupe;</mo>";                   // NEITHER A SUPERSET OF NOR EQUAL TO (???)
char/0x228A = "<mo>&subne;</mo>";                   // SUBSET OF WITH NOT EQUAL TO
char/0x228B = "<mo>&supne;</mo>";                   // SUPERSET OF WITH NOT EQUAL TO
// char/0x228C = "";                                // MULTISET
char/0x228D = "<mo>&cupdot;</mo>";                  // cupdot
char/0x228E = "<mo>&uplus;</mo>";                   // uplus
char/0x228F = "<mo>&sqsub;</mo>";                   // SQUARE IMAGE OF
char/0x2290 = "<mo>&sqsup;</mo>";                   // SQUARE ORIGINAL OF
char/0x2291 = "<mo>&sqsube;</mo>";                  // SQUARE IMAGE OF OR EQUAL TO
char/0x2292 = "<mo>&sqsupe;</mo>";                  // SQUARE ORIGINAL OF OR EQUAL TO
char/0x2293 = "<mo>&sqcap;</mo>";                   // SQUARE CAP
char/0x2294 = "<mo>&sqcup;</mo>";                   // SQUARE CUP
char/0x2295 = "<mo>&oplus;</mo>";                   // CIRCLED PLUS
char/0x2296 = "<mo>&ominus;</mo>";                  // CIRCLED MINUS
char/0x2297 = "<mo>&otimes;</mo>";                  // CIRCLED TIMES
char/0x2298 = "<mo>&osol;</mo>";                    // CIRCLED DIVISION SLASH
char/0x2299 = "<mo>&odot;</mo>";                    // CIRCLED DOT OPERATOR
char/0x229A = "<mo>&ocir;</mo>";                    // CIRCLED RING OPERATOR
char/0x229B = "<mo>&oast;</mo>";                    // CIRCLED ASTERISK OPERATOR
char/0x229C = "<mo>&oeq;</mo>";                     // CIRCLED EQUALS
char/0x229D = "<mo>&odash;</mo>";                   // CIRCLED DASH
char/0x229E = "<mo>&plusb;</mo>";                   // SQUARED PLUS
char/0x229F = "<mo>&minusb;</mo>";                  // SQUARED MINUS
char/0x22A0 = "<mo>&timesb;</mo>";                  // SQUARED TIMES
char/0x22A1 = "<mo>&sdotb;</mo>";                   // SQUARED DOT OPERATOR
char/0x22A2 = "<mo>&vdash;</mo>";                   // RIGHT TACK
char/0x22A3 = "<mo>&dashv;</mo>";                   // LEFT TACK
char/0x22A4 = "<mo>&top;</mo>";                     // DOWN TACK
char/0x22A5 = "<mo>&perp;</mo>";                    // UP TACK
char/0x22A6 = "<mo>&vdash;</mo>";                   // ASSERTION (???)
char/0x22A7 = "<mo>&models;</mo>";                  // MODELS
char/0x22A8 = "<mo>&vDash;</mo>";                   // TRUE
char/0x22A9 = "<mo>&Vdash;</mo>";                   // FORCES
char/0x22AA = "<mo>&Vvdash;</mo>";                  // TRIPLE VERTICAL BAR RIGHT TURNSTILE
char/0x22AB = "<mo>&VDash;</mo>";                   // DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
char/0x22AC = "<mo>&nvdash;</mo>";                  // not v dash
char/0x22AD = "<mo>&nvDash;</mo>";                  // not v double dash
char/0x22AE = "<mo>&nVdash;</mo>";                  // not double vertical dash
char/0x22AF = "<mo>&nVDash;</mo>";                  // not double vertical double dash
char/0x22B0 = "<mo>&prurel;</mo>";                  // PRECEDES UNDER RELATION
char/0x22B1 = "<mo>&scurel;</mo>";                  // SUCCEEDS UNDER RELATION
char/0x22B2 = "<mo>&vltri;</mo>";                   // NORMAL SUBGROUP OF
char/0x22B3 = "<mo>&vrtri;</mo>";                   // CONTAINS AS NORMAL SUBGROUP
char/0x22B4 = "<mo>&ltrie;</mo>";                   // NORMAL SUBGROUP OF OR EQUAL TO
char/0x22B5 = "<mo>&rtrie;</mo>";                   // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
char/0x22B6 = "<mo>&origof;</mo>";                  // ORIGINAL OF
char/0x22B7 = "<mo>&imof;</mo>";                    // IMAGE OF
char/0x22B8 = "<mo>&mumap;</mo>";                   // MULTIMAP
char/0x22B9 = "<mo>&hercon;</mo>";                  // HERMITIAN CONJUGATE MATRIX
char/0x22BA = "<mo>&intcal;</mo>";                  // INTERCALATE
char/0x22BB = "<mo>&veebar;</mo>";                  // XOR (???)
char/0x22BC = "<mo>&barwedge;</mo>";                // NAND (???)
// char/0x22BD = "";                                // NOR
char/0x22BE = "<mo>&angrtvb;</mo>";                 // RIGHT ANGLE WITH ARC
char/0x22BF = "<mo>&lrtri;</mo>";                   // RIGHT TRIANGLE
char/0x22C4 = "<mo>&diam;</mo>";                    // DIAMOND OPERATOR
char/0x22C5 = "<mo>&sdot;</mo>";                    // DOT OPERATOR
char/0x22C6 = "<mo>&sstarf;</mo>";                  // STAR OPERATOR
char/0x22C7 = "<mo>&divonx;</mo>";                  // DIVISION TIMES
char/0x22C8 = "<mo>&bowtie;</mo>";                  // BOWTIE
char/0x22C9 = "<mo>&ltimes;</mo>";                  // LEFT NORMAL FACTOR SEMIDIRECT PRODUCT
char/0x22CA = "<mo>&rtimes;</mo>";                  // RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT
char/0x22CB = "<mo>&lthree;</mo>";                  // LEFT SEMIDIRECT PRODUCT
char/0x22CC = "<mo>&rthree;</mo>";                  // RIGHT SEMIDIRECT PRODUCT
char/0x22CD = "<mo>&bsime;</mo>";                   // REVERSED TILDE EQUALS
char/0x22CE = "<mo>&cuvee;</mo>";                   // CURLY LOGICAL OR
char/0x22CF = "<mo>&cuwed;</mo>";                   // CURLY LOGICAL AND
char/0x22D0 = "<mo>&Sub;</mo>";                     // DOUBLE SUBSET
char/0x22D1 = "<mo>&Sup;</mo>";                     // DOUBLE SUPERSET
char/0x22D2 = "<mo>&Cap;</mo>";                     // DOUBLE INTERSECTION
char/0x22D3 = "<mo>&Cup;</mo>";                     // DOUBLE UNION
char/0x22D4 = "<mo>&fork;</mo>";                    // PITCHFORK
char/0x22D6 = "<mo>&ltdot;</mo>";                   // LESS-THAN WITH DOT
char/0x22D7 = "<mo>&gtdot;</mo>";                   // GREATER-THAN WITH DOT
char/0x22D8 = "<mo>&Ll;</mo>";                      // VERY MUCH LESS-THAN
char/0x22D9 = "<mo>&Gg;</mo>";                      // VERY MUCH GREATER-THAN
char/0x22DA = "<mo>&leg;</mo>";                     // LESS-THAN EQUAL TO OR GREATER-THAN
char/0x22DB = "<mo>&gel;</mo>";                     // GREATER-THAN EQUAL TO OR LESS-THAN
char/0x22DC = "<mo>&el;</mo>";                      // EQUAL TO OR LESS-THAN
char/0x22DD = "<mo>&eg;</mo>";                      // EQUAL TO OR GREATER-THAN
char/0x22DE = "<mo>&cuepr;</mo>";                   // EQUAL TO OR PRECEDES
char/0x22DF = "<mo>&cuesc;</mo>";                   // EQUAL TO OR SUCCEEDS
char/0x22E0 = "<mo>&nprcue;</mo>";                  // DOES NOT PRECEDE OR EQUAL
char/0x22E1 = "<mo>&nsccue;</mo>";                  // DOES NOT SUCCEED OR EQUAL
char/0x22E6 = "<mo>&lnsim;</mo>";                   // LESS-THAN BUT NOT EQUIVALENT TO
char/0x22E7 = "<mo>&gnsim;</mo>";                   // GREATER-THAN BUT NOT EQUIVALENT TO
char/0x22E8 = "<mo>&prnsim;</mo>";                  // PRECEDES BUT NOT EQUIVALENT TO
char/0x22E9 = "<mo>&scnsim;</mo>";                  // SUCCEEDS BUT NOT EQUIVALENT TO
char/0x22EA = "<mo>&nltri;</mo>";                   // NOT NORMAL SUBGROUP OF
char/0x22EB = "<mo>&nrtri;</mo>";                   // DOES NOT CONTAIN AS NORMAL SUBGROUP
char/0x22EC = "<mo>&nltrie;</mo>";                  // NOT NORMAL SUBGROUP OF OR EQUAL TO
char/0x22ED = "<mo>&nrtrie;</mo>";                  // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL
char/0x22EE = "<mo>&vellip;</mo>";                  // VERTICAL ELLIPSIS
char/0x22EF = "<mo>&ctdot;</mo>";                   // MIDLINE HORIZONTAL ELLIPSIS
char/0x22F0 = "<mo>&utdot;</mo>";                   // UP RIGHT DIAGONAL ELLIPSIS
char/0x22F1 = "<mo>&dtdot;</mo>";                   // DOWN RIGHT DIAGONAL ELLIPSIS
char/0x2306 = "<mo>&Barwed;</mo>";                  // PERSPECTIVE
char/0x2308 = "<mo>&lceil;</mo>";                   // LEFT CEILING
char/0x2309 = "<mo>&rceil;</mo>";                   // RIGHT CEILING
char/0x230A = "<mo>&lfloor;</mo>";                  // LEFT FLOOR
char/0x230B = "<mo>&rfloor;</mo>";                  // RIGHT FLOOR
char/0x231C = "<mo>&ulcorn;</mo>";                  // TOP LEFT CORNER
char/0x231D = "<mo>&urcorn;</mo>";                  // TOP RIGHT CORNER
char/0x231E = "<mo>&dlcorn;</mo>";                  // BOTTOM LEFT CORNER
char/0x231F = "<mo>&drcorn;</mo>";                  // BOTTOM RIGHT CORNER
// char/0x2320 = "";                                // TOP HALF INTEGRAL
// char/0x2321 = "";                                // BOTTOM HALF INTEGRAL
char/0x2322 = "<mo>&frown;</mo>";                   // FROWN
char/0x2323 = "<mo>&smile;</mo>";                   // SMILE
char/0x2329 = "<mo>&lang;</mo>";                    // LEFT-POINTING ANGLE BRACKET
char/0x232A = "<mo>&rang;</mo>";                    // RIGHT-POINTING ANGLE BRACKET
char/0x24C8 = "<mo>&oS;</mo>";                      // CIRCLED LATIN CAPITAL LETTER S
char/0x25A0 = "<mo>&squarf;</mo>";                  // BLACK SQUARE
char/0x25A1 = "<mo>&squ;</mo>";                     // WHITE SQUARE
char/0x25AD = "<mo>&bgx;</mo>";                     // WHITE RECTANGLE (???)
char/0x25B1 = "<mo>&oparlgrm;</mo>";                // WHITE PARALLELOGRAM (???)
char/0x25B2 = "<mo>&utrif;</mo>";                   // BLACK UP-POINTING TRIANGLE (???)
char/0x25B3 = "<mo>&xutri;</mo>";                   // WHITE UP-POINTING TRIANGLE
char/0x25B6 = "<mo>&vrtrif;</mo>";                  // BLACK RIGHT-POINTING TRIANGLE
char/0x25BC = "<mo>&dtrif;</mo>";                   // BLACK DOWN-POINTING TRIANGLE (???)
char/0x25BD = "<mo>&xdtri;</mo>";                   // WHITE DOWN-POINTING TRIANGLE
char/0x25C0 = "<mo>&vltrif;</mo>";                  // BLACK LEFT-POINTING TRIANGLE
char/0x25CA = "<mo>&diamond;</mo>";                 // LOZENGE
char/0x25CB = "<mo>&xcirc;</mo>";                   // WHITE CIRCLE
char/0x2660 = "<mo>&spades;</mo>";                  // BLACK SPADE SUIT
char/0x2663 = "<mo>&clubs;</mo>";                   // BLACK CLUB SUIT
char/0x2665 = "<mo>&heartsf;</mo>";                 // BLACK HEART SUIT
char/0x2666 = "<mo>&diamsf;</mo>";                  // BLACK DIAMOND SUIT
char/0x266D = "<mo>&flat;</mo>";                    // MUSIC FLAT SIGN
char/0x266E = "<mo>&natur;</mo>";                   // MUSIC NATURAL SIGN
char/0x266F = "<mo>&sharp;</mo>";                   // MUSIC SHARP SIGN
char/0x2720 = "<mo>&malt;</mo>";                    // MALTESE CROSS
char/0x301A = "<mo>&lopenb;</mo>";                  // LEFT WHITE SQUARE BRACKET (???)
char/0x301B = "<mo>&ropenb;</mo>";                  // RIGHT WHITE SQUARE BRACKET (???)
// char/0x301E = "";                                // DOUBLE PRIME QUOTATION MARK

// ------------   Unicode private zone characters -------------------------
                            
// char/0xE900 = "";                                // EQUALS HAT BELOW
char/0xE901 = "<mo>&pluse;</mo>";                   // PLUS ABOVE EQUALS
char/0xE902 = "<mo>&eplus;</mo>";                   // PLUS BELOW EQUALS
char/0xE903 = "<mo>&plussim;</mo>";                 // PLUS ABOVE TILDE
char/0xE904 = "<mo>&simplus;</mo>";                 // PLUS BELOW TILDE
// char/0xE909 = "";                                // EQUAL TO (DOUBLE) OR LESS-THAN
// char/0xE90A = "";                                // CONTAINS OR EQUAL TO
char/0xE90B = "<mo>&supE;</mo>";                    // SUPERSET OF OR EQUAL TO (DOUBLE)
char/0xE90C = "<mo>&subE;</mo>";                    // SUBSET OF OR EQUAL TO (DOUBLE)
// char/0xE911 = "";                                // SMALL TILDE OPERATOR
// char/0xE912 = "";                                // ELEMENT OF OR EQUAL TO
// char/0xE913 = "";                                // EQUAL TO (DOUBLE) OR GREATER-THAN
// char/0xE91F = "";                                // ALMOST EQUAL TO MINUS
char/0xE922 = "<mo>&lEg</mo>";                      // LESS-THAN EQUAL TO (DOUBLE) OR GREATER-THAN
// char/0xE923 = "";                                // EQUIVALENT TO OR GREATER-THAN
char/0xE924 = "<mo>&simdot;</mo>";                  // TILDE WITH DOT
char/0xE925 = "<mover accent='true'><mo>&sim;</mo><mo>&die;</mo></mover>";
                                                    // TILDE WITH TWO DOTS
// char/0xE926 = "";                                // LESS-THAN GREATER-THAN OR EQUAL TO (DOUBLE)
// char/0xE927 = "";                                // GREATER-THAN LESS-THAN OR EQUAL TO (DOUBLE)
// char/0xE928 = "";                                // EQUIVALENT TO OR LESS-THAN (ANGLED)
// char/0xE929 = "";                                // EQUIVALENT TO OR GREATER-THAN (ANGLED)
// char/0xE92A = "";                                // LEFT OPEN BOX OPERATOR
// char/0xE92B = "";                                // RIGHT OPEN BOX OPERATOR
// char/0xE92C = "";                                // EQUIVALENT TO OR LESS-THAN
char/0xE92D = "<mo>&gEl;</mo>";                     // GREATER-THAN EQUAL TO (DOUBLE) OR LESS-THAN
char/0xE92E = "<mo>&smid;</mo>";                    // DIVIDES (VARIATION)
char/0xE92F = "<mo>&spar;</mo>";                    // PARALLEL TO (VARIATION)
// char/0xE930 = "";                                // LESS-THAN OR EQUAL TO (ANGLED)
// char/0xE931 = "";                                // GREATER-THAN OR EQUAL TO (ANGLED)
char/0xE932 = "<mo>&lap;</mo>";                     // LESS-THAN OR APPROXIMATELY EQUAL TO
char/0xE933 = "<mo>&gap;</mo>";                     // GREATER-THAN OR APPROXIMATELY EQUAL TO
// char/0xE938 = "";                                // PRECEDES OR EQUAL TO (STRAIGHT)
// char/0xE939 = "";                                // SUCCEEDS OR EQUAL TO (STRAIGHT)
char/0xE93A = "<mo>&prap;</mo>";                    // PRECEDES OR EQUIVALENT TO (DOUBLE)
char/0xE93B = "<mo>&scap;</mo>";                    // SUCCEEDS OR EQUIVALENT TO (DOUBLE)
// char/0xE948 = "";                                // SATISFIED BY
// char/0xE949 = "";                                // LAZY S
// char/0xE94A = "";                                // NOT ASSERTION
// char/0xE980 = "";                                // SPHERICAL ANGLE OPENING UP
// char/0xE981 = "";                                // CIRCLED MINUS (ALTERNATE)
// char/0xE982 = "";                                // SMALL SQUARE SOLID
// char/0xE983 = "";                                // INTEGER DIVIDE
// char/0xE984 = "";                                // CIRCLED BAR
// char/0xE9A0 = "";                                // SINE WAVE (NEGATIVE)
// char/0xE9A1 = "";                                // PARENTHESIZED DOT
// char/0xE9A2 = "";                                // PARENTHESES
char/0xEA06 = "<mo>&nlE;</mo>";                     // NOT LESS-THAN OR EQUAL TO (DOUBLE)
char/0xEA07 = "<mo>&ngE;</mo>";                     // NOT GREATER-THAN OR EQUAL TO (DOUBLE)
// char/0xEA09 = "";                                // NEITHER EQUAL TO (DOUBLE) NOR LESS-THAN
// char/0xEA0A = "";                                // DOES NOT CONTAIN OR EQUAL TO
char/0xEA0B = "<mo>&nsupE;</mo>";                   // NEITHER SUPERSET OF NOR EQUAL TO (DOUBLE)
char/0xEA0C = "<mo>&nsubE;</mo>";                   // NEITHER SUBSET OF NOR EQUAL TO (DOUBLE)
// char/0xEA0E = "";                                // NEITHER EQUAL TO NOR GREATER-THAN
// char/0xEA0F= "";                                // NOT MINUS TILDE OPERATOR
// char/0xEA10 = "";                                // NEITHER EQUAL TO NOR LESS-THAN
// char/0xEA11 = "";                                // SMALL NOT TILDE OPERATOR
// char/0xEA12 = "";                                // NOT ELEMENT OF OR EQUAL TO
// char/0xEA13 = "";                                // NEITHER EQUAL TO (DOUBLE) NOR GREATER-THAN
// char/0xEA1F = "";                                // NOT ALMOST EQUAL TO MINUS
char/0xEA2E = "<mo>&nsmid;</mo>";                   // DOES NOT DIVIDE (VARIATION)
char/0xEA2F = "<mo>&nspar;</mo>";                   // NOT PARALLEL TO (VARIATION)
// char/0xEA30 = "";                                // NOT LESS-THAN NOR EQUAL TO (ANGLED)
// char/0xEA31 = "";                                // NOT GREATER-THAN NOR EQUAL TO (ANGLED)
char/0xEA32 = "<mo>&lnap;</mo>";                    // LESS-THAN BUT NOT APPROXIMATELY EQUAL TO
char/0xEA33 = "<mo>&gnap;</mo>";                    // GREATER-THAN BUT NOT APPROXIMATELY EQUAL TO
char/0xEA34 = "<mo>&lne;</mo>";                     // LESS-THAN OR NOT EQUAL TO (SINGLE)
char/0xEA35 = "<mo>&gne;</mo>";                     // GREATER-THAN OR NOT EQUAL TO (SINGLE)
// char/0xEA38 = "";                                // DOES NOT PRECEDE OR EQUAL (STRAIGHT)
// char/0xEA39 = "";                                // DOES NOT SUCCEED OR EQUAL (STRAIGHT)
char/0xEA3A = "<mo>&prapp;</mo>";                   // PRECEDES BUT NOT EQUIVALENT TO (DOUBLE)
char/0xEA3B = "<mo>&scnap;</mo>";                   // SUCCEEDS BUT NOT EQUIVALENT TO (DOUBLE)
// char/0xEA3C = "";                                // PRECEDES BUT NOT EQUAL TO
// char/0xEA3D = "";                                // SUCCEEDS BUT NOT EQUAL TO
char/0xEA40 = "<mo>&prnE;</mo>";                    // PRECEDES BUT NOT EQUAL TO (DOUBLE)
char/0xEA41 = "<mo>&scnE;</mo>";                    // SUCCEEDS BUT NOT EQUAL TO (DOUBLE)
char/0xEA42 = "<mo>&vsubne;</mo>";                  // NOT SUBSET OF NOR EQUAL TO
char/0xEA43 = "<mo>&vsupne;</mo>";                  // NOT SUPERSET OF NOR EQUAL TO
char/0xEA44 = "<mo>&subnE;</mo>";                   // SUBSET OF OR NOT EQUAL TO (DOUBLE)
char/0xEA45 = "<mo>&supnE;</mo>";                   // SUPERSET OF OR NOT EQUAL TO (DOUBLE)
char/0xEA46 = "<mo>&vsubnE;</mo>";                  // NOT SUBSET OF NOR EQUAL TO (DOUBLE)
char/0xEA47 = "<mo>&vsupnE;</mo>";                  // NOT SUPERSET OF NOR EQUAL TO (DOUBLE)
// char/0xEA80 = "";                                // NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO (VERTICAL BAR)
// char/0xEA81 = "";                                // NOT ASYMPTOTICALLY EQUAL TO (VERTICAL BAR)
// char/0xEA82 = "";                                // NOT LESS-THAN (VERTICAL BAR)
// char/0xEA83 = "";                                // NOT GREATER-THAN (VERTICAL BAR)
// char/0xEA84 = "";                                // NOT ALMOST EQUAL TO (VERTICAL BAR)
char/0xEA85 = "<mo>&nvsim;</mo>";                   // NOT TILDE (VERTICAL BAR)
// char/0xEA86 = "";                                // NOT LESS-THAN OR EQUAL TO (DOUBLE) (VERTICAL BAR)
// char/0xE                                         // NOT GREATER-THAN OR EQUAL TO (DOUBLE) (VERTICAL BAR)
// char/0xEA88 = "";                                // DOES NOT PRECEDE (VERTICAL BAR)
// char/0xEA89 = "";                                // NEITHER EQUAL TO (DOUBLE) NOR LESS-THAN (VERTICAL BAR)
// char/0xEA8A = "";                                // NOT CONTAINS OR EQUAL TO (VERTICAL BAR)
// char/0xEA8B = "";                                // NOT SUPERSET OF OR EQUAL TO (DOUBLE) (VERTICAL BAR)
// char/0xEA8C = "";                                // NOT SUBSET OF OR EQUAL TO (DOUBLE) (VERTICAL BAR)
// char/0xEA8D = "";                                // DOES NOT SUCCEED (VERTICAL BAR)
// char/0xEA8E = "";                                // NEITHER EQUAL TO NOR GREATER-THAN (VERTICAL BAR)
// char/0xEA8F = "";                                // NOT MINUS TILDE OPERATOR (VERTICAL BAR)
// char/0xEA90 = "";                                // NEITHER EQUAL TO NOR LESS-THAN (VERTICAL BAR)
// char/0xEA91 = "";                                // SMALL NOT TILDE OPERATOR (VERTICAL BAR)
// char/0xEA92 = "";                                // NOT ELEMENT OF OR EQUAL TO (VERTICAL BAR)
// char/0xEA93 = "";                                // NEITHER EQUAL TO (DOUBLE) NOR GREATER-THAN (VERTICAL BAR)
// char/0xEA94 = "";                                // NOT ALMOST EQUAL (VERTICAL BAR)
// char/0xEA95 = "";                                // DOES NOT PRECEDE OR EQUAL (VERTICAL BAR)
// char/0xEA96 = "";                                // NOT AN ELEMENT OF (VERTICAL BAR)
// char/0xEA97 = "";                                // DOES NOT SUCCEED OR EQUAL (VERTICAL BAR)
// char/0xEA9A = "";                                // NOT EQUAL TO (VERTICAL BAR)
// char/0xEA9B = "";                                // DOES NOT CONTAIN (VERTICAL BAR)
// char/0xEA9C = "";                                // NOT EQUIVALENT TO (VERTICAL BAR)
// char/0xEA9D = "";                                // NOT LESS-THAN OR EQUAL TO (VERTICAL BAR)
// char/0xEA9E = "";                                // NOT GREATER-THAN OR EQUAL TO (VERTICAL BAR)
// char/0xEA9F = "";                                // NOT ALMOST EQUAL TO MINUS (VERTICAL BAR)
// char/0xEAB6 = "";                                // LESS-THAN BUT NOT EQUAL TO (VERTICAL BAR)
// char/0xEAB7 = "";                                // GREATER-THAN BUT NOT EQUAL TO (VERTICAL BAR)
// char/0xEABE = "";                                // DOES NOT EQUAL OR PRECEDE
// char/0xEABF = "";                                // DOES NOT EQUAL OR SUCCEED
// char/0xEB00 = "";                                // COMBINING ARROW ABOVE EXTENDER
char/0xEB01 = "<mo>&arrlrsl</mo>";                   // ARROW RIGHTWARDS OVER SMALL ARROW LEFTWARDS
char/0xEB02 = "<mo>&arrsrll</mo>";                  // SMALL ARROW RIGHTWARDS OVER ARROW LEFTWARDS
// char/0xEB03 = "";                                // HARPOON RIGHTWARDS OVER SMALL HARPOON LEFTWARDS
// char/0xEB04 = "";                                // SMALL HARPOON RIGHTWARDS OVER HARPOON LEFTWARDS
char/0xEB05 = "<mo>&neswsarr;</mo>";                // DOUBLE ARROW NORTHEAST SOUTHWEST
char/0xEB06 = "<mo>&nwsesarr;</mo>";                // DOUBLE ARROW NORTHWEST SOUTHEAST
// char/0xEB07 = "";                                // HARPOON EXTENDER
// char/0xEB08 = "";                                // ANTICLOCKWISE ARC LEFTWARDS ARROW
// char/0xEB09 = "";                                // ANTICLOCKWISE ARC RIGHTWARDS ARROW
// char/0xEB0A = "";                                // WAVY RIGHTWARDS ARROW
// char/0xEB0B = "";                                // LARGE RIGHTWARDS ARROW ACCENT
// char/0xEB0C = "";                                // LARGE LEFTWARDS ARROW ACCENT
// char/0xEB0D = "";                                // LEFTWARDS ARROWHEAD
// char/0xEB0E = "";                                // RIGHTWARDS ARROWHEAD
// char/0xEB0F = "";                                // LARGE LEFT RIGHT ARROW WITH STROKE
// char/0xEB10 = "";                                // DOUBLE ARROW EXTENDER
// char/0xEB11 = "";                                // LARGE LEFT RIGHT DOUBLE ARROW WITH STROKE
// char/0xEB12 = "";                                // DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW
// char/0xEB13 = "";                                // LEFTWARDS ARROW WITH CORNER DOWNWARDS
// char/0xEB14 = "";                                // RIGHTWARDS ARROW WITH CORNER UPWARDS
// char/0xEB15 = "";                                // LEFTWARDS ARROW WITH CORNER UPWARDS
// char/0xEB16 = "";                                // ANTICLOCKWISE TOP SEMICIRCLE ARROW WITH PLUS
// char/0xEB17 = "";                                // CLOCKWISE TOP SEMICIRCLE ARROW WITH MINUS
// char/0xEB18 = "";                                // RIGHTWARDS ARROW WITH TAIL WITH STROKE
// char/0xEB19 = "";                                // Right harpoon below accent
// char/0xEB1A = "";                                // Left harpoon below accent
// char/0xEC00 = "";                                // DOWN-POINTING CURLY BRACKET LEFT
// char/0xEC01 = "";                                // DOWN-POINTING CURLY BRACKET MID
// char/0xEC02 = "";                                // DOWN-POINTING CURLY BRACKET RIGHT
// char/0xEC03 = "";                                // HORIZONTAL CURLY BRACKET EXTENDER
// char/0xEC04 = "";                                // UP-POINTING CURLY BRACKET LEFT
// char/0xEC05 = "";                                // UP-POINTING CURLY BRACKET MID
// char/0xEC06 = "";                                // UP-POINTING CURLY BRACKET RIGHT
char/0xEC07 = "<mo>&lvertdel;</mo>";                // LEFT VERTICAL BAR
char/0xEC08 = "<mo>&rvertdel;</mo>";                // RIGHT VERTICAL BAR
char/0xEC09 = "<mo>&lVertdel;</mo>";                // LEFT DOUBLE VERTICAL BAR
char/0xEC0A = "<mo>&Vertdel;</mo>";                 // RIGHT DOUBLE VERTICAL BAR
// char/0xEC0B = "";                                // HORIZONTAL SQUARE BRACKET EXTENDER
char/0xEC0C = "<mo>&udrbrk;</mo>";                  // DOWN-POINTING SQUARE BRACKET
char/0xEC0D = "<mo>&ovrbrk;</mo>";                  // UP-POINTING SQUARE BRACKET
char/0xEC0E = "<mo>&dloang;</mo>";                  // DOWN-POINTING SQUARE BRACKET LEFT
char/0xEC0F = "<mo>&droang;</mo>";                  // DOWN-POINTING SQUARE BRACKET RIGHT
char/0xEC10 = "<mo>&dluang;</mo>";                  // UP-POINTING SQUARE BRACKET LEFT
char/0xEC11 = "<mo>&druang;</mo>";                  // UP-POINTING SQUARE BRACKET RIGHT
// char/0xEC12 = "";                                // LEFT PARENTHESES 1
// char/0xEC13 = "";                                // LEFT PARENTHESES 2
// char/0xEC14 = "";                                // LEFT PARENTHESES 3
// char/0xEC15 = "";                                // LEFT PARENTHESES 4
// char/0xEC16 = "";                                // RIGHT PARENTHESES 1
// char/0xEC17 = "";                                // RIGHT PARENTHESES 2
// char/0xEC18 = "";                                // RIGHT PARENTHESES 3
// char/0xEC19 = "";                                // RIGHT PARENTHESES 4
// char/0xEC1A = "";                                // RADICAL 1
// char/0xEC1B = "";                                // RADICAL 2
// char/0xEC1C = "";                                // RADICAL 3
// char/0xEC1D = "";                                // RADICAL 4
// char/0xEC1E = "";                                // RADICAL 5
// char/0xEC1F = "";                                // RADICAL BOTTOM
// char/0xEC20 = "";                                // RADICAL VERTICAL EXTENDER
// char/0xEC21 = "";                                // RADICAL TOP
// char/0xED00 = "";                                // SLANTED NABLA
// char/0xED01 = "";                                // MIRROR G
char/0xED02 = "<mi>&jmath;</mi>";                   // LATIN SMALL LETTER DOTLESS J
// char/0xED03 = "";                                // GREEK SMALL LETTER EPSILON (VARIATION)
// char/0xEE00 = "";                                // ANTICLOCKWISE CONTOUR INTEGRAL CIRCLE
// char/0xEE01 = "";                                // CLOCKWISE CONTOUR INTEGRAL CIRCLE
char/0xEE01 = "<mstyle displaystyle='true'><mo largeop='true'>&awconint;</mo></mstyle>";    
						    // CLOCKWISE CONTOUR INTEGRAL CIRCLE
char/0xEE02 = "<mstyle displaystyle='true'><mo largeop='true'>&awconint;</mo></mstyle>";
                                                    // Anticlockwise contour integral circle (big) 
char/0xEE03 = "<mstyle displaystyle='true'><mo largeop='true'>&conint;</mo></mstyle>";
                                                    // CLOCKWISE CONTOUR INTEGRAL CIRCLE (BIG)
char/0xEE04 = "<mo stretchy='true'>&tilde;</mo>";   // COMBINING TILDE TWO SPACE
char/0xEE05 = "<mo stretchy='true'>&tilde;</mo>";   // COMBINING TILDE THREE SPACE
char/0xEE06 = "<mo stretchy='true'>&tilde;</mo>";   // COMBINING TILDE FOUR SPACE
char/0xEE07 = "<mo stretchy='true'>&circ;</mo>";    // COMBINING CIRCUMFLEX TWO SPACE
char/0xEE08 = "<mo stretchy='true'>&circ;</mo>";    // COMBINING CIRCUMFLEX THREE SPACE
char/0xEE09 = "<mo stretchy='true'>&circ;</mo>";    // COMBINING CIRCUMFLEX FOUR SPACE
char/0xEE0A = "<mo stretchy='true'>&frown;</mo>";   // COMBINING ARC TWO SPACE
char/0xEE0B = "<mo stretchy='true'>&frown;</mo>";   // COMBINING ARC THREE SPACE
char/0xEE0C = "<mo stretchy='true'>&frown;</mo>";   // COMBINING ARC FOUR SPACE
// char/0xEE0D = "";                                // JOINT STATUS
// char/0xEE0E = "";                                // JOINT STATUS LEFT
// char/0xEE0F = "";                                // JOINT STATUS RIGHT
// char/0xEE10 = "";                                // JOINT STATUS EXTENDER
// char/0xEE17 = "";                                // ASYMPTOTICALLY EQUAL TO ACCENT
// char/0xEE18 = "";                                // EQUAL SIGN ACCENT
char/0xEE19 = "<mo>&qprime;</mo>";                  // QUADRUPLE PRIME
// char/0xEE1A = "";                                // BAR ACCENT WITH OPEN CIRCLE LEFT
// char/0xEE1B = "";                                // BAR ACCENT WITH CLOSED CIRCLE LEFT
// char/0xEE1C = "";                                // BAR ACCENT WITH OPEN CIRCLE RIGHT
// char/0xEE1D = "";                                // BAR ACCENT WITH OVER DOT
// char/0xEE1E = "";                                // BAR ACCENT WITH UNDER DOT
// char/0xEE1F = "";                                // BAR ACCENT WITH DOUBLE OVER DOT
// char/0xEE20 = "";                                // BAR ACCENT WITH DOUBLE UNDER DOT
// char/0xEE21 = "";                                // BAR ACCENT WITH CARET
// char/0xEE22 = "";                                // THICK UNDER BAR ACCENT
// char/0xEE23 = "";                                // BAR ACCENT WITH CLOSED CIRCLE RIGHT
// char/0xEE24 = "";                                // LARGE DOT ABOVE

// --------------------------   Spaces, etc.   ---------------------------
                            
char/0xEF00 = "<malignmark/>";                      // ALIGNMENT MARK
char/0xEF01 = "<mi>&ZeroWidthSpace;</mi>";          // MT ZERO SPACE
char/0xEF02 = "<mi>&thinsp;</mi>";                  // MT THIN SPACE
char/0xEF03 = "<mi>&MediumSpace;</mi>";             // MT MEDIUM SPACE
char/0xEF04 = "<mi>&ThickSpace;</mi>";              // MT THICK SPACE
char/0xEF05 = "<mi>&emsp;</mi>";                    // MT EM SPACE
char/0xEF06 = "<mi>&emsp;&emsp;</mi>";              // MT 2 EM SPACE
// char/0xEF07 = "";                                // MT INNER SPACE
char/0xEF08 = "<mi>&hairsp;</mi>";                  // MT 1 POINT SPACE
// char/0xEF09 = "";                                // UNKNOWN OR MISSING CHARACTER

// --------------------------   Fraktur characters   ----------------------
                            
char/0xF000 = "<mi>&Afr;</mi>";                     // BLACK-LETTER CAPITAL A
char/0xF001 = "<mi>&Bfr;</mi>";                     // BLACK-LETTER CAPITAL B
char/0xF003 = "<mi>&Dfr;</mi>";                     // BLACK-LETTER CAPITAL D
char/0xF004 = "<mi>&Efr;</mi>";                     // BLACK-LETTER CAPITAL E
char/0xF005 = "<mi>&Ffr;</mi>";                     // BLACK-LETTER CAPITAL F
char/0xF006 = "<mi>&Gfr;</mi>";                     // BLACK-LETTER CAPITAL G
char/0xF009 = "<mi>&Jfr;</mi>";                     // BLACK-LETTER CAPITAL J
char/0xF00A = "<mi>&Kfr;</mi>";                     // BLACK-LETTER CAPITAL K
char/0xF00B = "<mi>&Lfr;</mi>";                     // BLACK-LETTER CAPITAL L
char/0xF00C = "<mi>&Mfr;</mi>";                     // BLACK-LETTER CAPITAL M
char/0xF00D = "<mi>&Nfr;</mi>";                     // BLACK-LETTER CAPITAL N
char/0xF00E = "<mi>&Ofr;</mi>";                     // BLACK-LETTER CAPITAL O
char/0xF00F = "<mi>&Pfr;</mi>";                     // BLACK-LETTER CAPITAL P
char/0xF010 = "<mi>&Qfr;</mi>";                     // BLACK-LETTER CAPITAL Q
char/0xF012 = "<mi>&Sfr;</mi>";                     // BLACK-LETTER CAPITAL S
char/0xF013 = "<mi>&Tfr;</mi>";                     // BLACK-LETTER CAPITAL T
char/0xF014 = "<mi>&Ufr;</mi>";                     // BLACK-LETTER CAPITAL U
char/0xF015 = "<mi>&Vfr;</mi>";                     // BLACK-LETTER CAPITAL V
char/0xF016 = "<mi>&Wfr;</mi>";                     // BLACK-LETTER CAPITAL W
char/0xF017 = "<mi>&Xfr;</mi>";                     // BLACK-LETTER CAPITAL X
char/0xF018 = "<mi>&Yfr;</mi>";                     // BLACK-LETTER CAPITAL Y
char/0xF01A = "<mi>&afr;</mi>";                     // BLACK-LETTER SMALL A
char/0xF01B = "<mi>&bfr;</mi>";                     // BLACK-LETTER SMALL B
char/0xF01C = "<mi>&cfr;</mi>";                     // BLACK-LETTER SMALL C
char/0xF01D = "<mi>&dfr;</mi>";                     // BLACK-LETTER SMALL D
char/0xF01E = "<mi>&efr;</mi>";                     // BLACK-LETTER SMALL E
char/0xF01F = "<mi>&ffr;</mi>";                     // BLACK-LETTER SMALL F
char/0xF020 = "<mi>&gfr;</mi>";                     // BLACK-LETTER SMALL G
char/0xF021 = "<mi>&hfr;</mi>";                     // BLACK-LETTER SMALL H
char/0xF022 = "<mi>&ifr;</mi>";                     // BLACK-LETTER SMALL I
char/0xF023 = "<mi>&jfr;</mi>";                     // BLACK-LETTER SMALL J
char/0xF024 = "<mi>&kfr;</mi>";                     // BLACK-LETTER SMALL K
char/0xF025 = "<mi>&lfr;</mi>";                     // BLACK-LETTER SMALL L
char/0xF026 = "<mi>&mfr;</mi>";                     // BLACK-LETTER SMALL M
char/0xF027 = "<mi>&nfr;</mi>";                     // BLACK-LETTER SMALL N
char/0xF028 = "<mi>&ofr;</mi>";                     // BLACK-LETTER SMALL O
char/0xF029 = "<mi>&pfr;</mi>";                     // BLACK-LETTER SMALL P
char/0xF02A = "<mi>&qfr;</mi>";                     // BLACK-LETTER SMALL Q
char/0xF02B = "<mi>&rfr;</mi>";                     // BLACK-LETTER SMALL R
char/0xF02C = "<mi>&sfr;</mi>";                     // BLACK-LETTER SMALL S
char/0xF02D = "<mi>&tfr;</mi>";                     // BLACK-LETTER SMALL T
char/0xF02E = "<mi>&ufr;</mi>";                     // BLACK-LETTER SMALL U
char/0xF02F = "<mi>&vfr;</mi>";                     // BLACK-LETTER SMALL V
char/0xF030 = "<mi>&wfr;</mi>";                     // BLACK-LETTER SMALL W
char/0xF031 = "<mi>&xfr;</mi>";                     // BLACK-LETTER SMALL X
char/0xF032 = "<mi>&yfr;</mi>";                     // BLACK-LETTER SMALL Y
char/0xF033 = "<mi>&zfr;</mi>";                     // BLACK-LETTER SMALL Z

// ------------------   Other Open face characters  ----------------------------
                            
char/0xF080 = "<mi>&Aopf;</mi>";                    // DOUBLE-STRUCK CAPITAL A
char/0xF081 = "<mi>&Bopf;</mi>";                    // DOUBLE-STRUCK CAPITAL B
char/0xF083 = "<mi>&Dopf;</mi>";                    // DOUBLE-STRUCK CAPITAL D
char/0xF084 = "<mi>&Eopf;</mi>";                    // DOUBLE-STRUCK CAPITAL E
char/0xF085 = "<mi>&Fopf;</mi>";                    // DOUBLE-STRUCK CAPITAL F
char/0xF086 = "<mi>&Gopf;</mi>";                    // DOUBLE-STRUCK CAPITAL G
char/0xF088 = "<mi>&Iopf;</mi>";                    // DOUBLE-STRUCK CAPITAL I
char/0xF089 = "<mi>&Jopf;</mi>";                    // DOUBLE-STRUCK CAPITAL J
char/0xF08A = "<mi>&Kopf;</mi>";                    // DOUBLE-STRUCK CAPITAL K
char/0xF08B = "<mi>&Lopf;</mi>";                    // DOUBLE-STRUCK CAPITAL L
char/0xF08C = "<mi>&Mopf;</mi>";                    // DOUBLE-STRUCK CAPITAL M
char/0xF08E = "<mi>&Oopf;</mi>";                    // DOUBLE-STRUCK CAPITAL O
char/0xF092 = "<mi>&Sopf;</mi>";                    // DOUBLE-STRUCK CAPITAL S
char/0xF093 = "<mi>&Topf;</mi>";                    // DOUBLE-STRUCK CAPITAL T
char/0xF094 = "<mi>&Uopf;</mi>";                    // DOUBLE-STRUCK CAPITAL U
char/0xF095 = "<mi>&Vopf;</mi>";                    // DOUBLE-STRUCK CAPITAL V
char/0xF096 = "<mi>&Wopf;</mi>";                    // DOUBLE-STRUCK CAPITAL W
char/0xF097 = "<mi>&Xopf;</mi>";                    // DOUBLE-STRUCK CAPITAL X
char/0xF098 = "<mi>&Yopf;</mi>";                    // DOUBLE-STRUCK CAPITAL Y
char/0xF0A4 = "<mi>&Kopf;</mi>";                    // DOUBLE-STRUCK SMALL K

// ---------------     Other Caligrapic characters  ---------------------
                            
char/0xF100 = "<mi>&Ascr;</mi>";                    // SCRIPT CAPITAL A
char/0xF102 = "<mi>&Cscr;</mi>";                    // SCRIPT CAPITAL C
char/0xF103 = "<mi>&Dscr;</mi>";                    // SCRIPT CAPITAL D
char/0xF106 = "<mi>&Gscr;</mi>";                    // SCRIPT CAPITAL G
char/0xF109 = "<mi>&Jscr;</mi>";                    // SCRIPT CAPITAL J
char/0xF10A = "<mi>&Kscr;</mi>";                    // SCRIPT CAPITAL K
char/0xF10D = "<mi>&Nscr;</mi>";                    // SCRIPT CAPITAL N
char/0xF10E = "<mi>&Oscr;</mi>";                    // SCRIPT CAPITAL O
char/0xF110 = "<mi>&Qscr;</mi>";                    // SCRIPT CAPITAL Q
char/0xF112 = "<mi>&Sscr;</mi>";                    // SCRIPT CAPITAL S
char/0xF113 = "<mi>&Tscr;</mi>";                    // SCRIPT CAPITAL T
char/0xF114 = "<mi>&Uscr;</mi>";                    // SCRIPT CAPITAL U
char/0xF115 = "<mi>&Vscr;</mi>";                    // SCRIPT CAPITAL V
char/0xF116 = "<mi>&Wscr;</mi>";                    // SCRIPT CAPITAL W
char/0xF117 = "<mi>&Xscr;</mi>";                    // SCRIPT CAPITAL X
char/0xF118 = "<mi>&Yscr;</mi>";                    // SCRIPT CAPITAL Y
char/0xF119 = "<mi>&Zscr;</mi>";                    // SCRIPT CAPITAL Z

// --------------   Some special delimiter characters  ----------------------------                            
// char/0xF8E5 = "";                                // RADICAL EXTENDER
// char/0xF8E6 = "";                                // VERTICAL ARROW EXTENDER
// char/0xF8E7 = "";                                // HORIZONTAL ARROW EXTENDER
// char/0xF8E8 = "";                                // REGISTERED SIGN SANS SERIF
// char/0xF8E9 = "";                                // COPYRIGHT SIGN SANS SERIF
// char/0xF8EA = "";                                // TRADE MARK SIGN SANS SERIF
// char/0xF8EB = "";                                // LEFT PAREN TOP
// char/0xF8EC = "";                                // LEFT PAREN EXTENDER
// char/0xF8ED = "";                                // LEFT PAREN BOTTOM
// char/0xF8EE = "";                                // LEFT SQUARE BRACKET TOP
// char/0xF8EF = "";                                // LEFT SQUARE BRACKET EXTENDER
// char/0xF8F0 = "";                                // LEFT SQUARE BRACKET BOTTOM
// char/0xF8F1 = "";                                // LEFT CURLY BRACKET TOP
// char/0xF8F2 = "";                                // LEFT CURLY BRACKET MID
// char/0xF8F3 = "";                                // LEFT CURLY BRACKET BOTTOM
// char/0xF8F4 = "";                                // CURLY BRACKET EXTENDER
// char/0xF8F5 = "";                                // INTEGRAL EXTENDER
// char/0xF8F6 = "";                                // RIGHT PAREN TOP
// char/0xF8F7 = "";                                // RIGHT PAREN EXTENDER
// char/0xF8F8 = "";                                // RIGHT PAREN BOTTOM
// char/0xF8F9 = "";                                // RIGHT SQUARE BRACKET TOP
// char/0xF8FA = "";                                // RIGHT SQUARE BRACKET EXTENDER
// char/0xF8FB = "";                                // RIGHT SQUARE BRACKET BOTTOM
// char/0xF8FC = "";                                // RIGHT CURLY BRACKET TOP
// char/0xF8FD = "";                                // RIGHT CURLY BRACKET MID
// char/0xF8FE = "";                                // RIGHT CURLY BRACKET BOTTOM
// char/0xF8FF = "";                                // APPLE LOGO
char/0xFB01 = "<mo>&filig;</mo>";                   // LATIN SMALL LIGATURE FI
char/0xFB02 = "<mo>&fllig;</mo>";                   // LATIN SMALL LIGATURE FL
// char/0xFE37 = "";                                // PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
// char/0xFE38 = "";                                // PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET







  
