diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /systems/android/hktex/HKtex2/src/worker4math/hktex2/Symbol.java |
Initial commit
Diffstat (limited to 'systems/android/hktex/HKtex2/src/worker4math/hktex2/Symbol.java')
-rw-r--r-- | systems/android/hktex/HKtex2/src/worker4math/hktex2/Symbol.java | 2861 |
1 files changed, 2861 insertions, 0 deletions
diff --git a/systems/android/hktex/HKtex2/src/worker4math/hktex2/Symbol.java b/systems/android/hktex/HKtex2/src/worker4math/hktex2/Symbol.java new file mode 100644 index 0000000000..3f2c892bf4 --- /dev/null +++ b/systems/android/hktex/HKtex2/src/worker4math/hktex2/Symbol.java @@ -0,0 +1,2861 @@ +// +// Latex Project Public Licence (lppl1.3) applies +// Originally written by Kwanleung Tse +// First Release : 1st July, 2014 +// Last Update : 25th September, 2014 +// +// + +package worker4math.hktex2; + +import java.util.HashMap; + +public class Symbol { + + public static HashMap<String, Integer> symboltype = new HashMap<String, Integer>(); + public static HashMap<String, Integer> symbolsubtype = new HashMap<String, Integer>(); + public static HashMap<String, String> symbolunicode = new HashMap<String, String>(); + public static HashMap<String, String> matchsymbol = new HashMap<String, String>(); + +public void symbol() { + + + matchsymbol.put("lparen","rparen"); + matchsymbol.put("lbrack","rbrack"); + matchsymbol.put("lbrace","rbrace"); +/* matchsymbol.put("lceil","rceil"); + matchsymbol.put("lfloor","rfloor"); + matchsymbol.put("ulcorner","urcorner"); + matchsymbol.put("llcorner","rlcorner"); + matchsymbol.put("lbag","rbag"); + matchsymbol.put("lBrack","rBrack"); + matchsymbol.put("langle","rangle"); + matchsymbol.put("lAngle","rAngle"); + matchsymbol.put("Lbrbrak","Rbrbrak"); + matchsymbol.put("lgroup","rgroup"); + matchsymbol.put("lBrace","rBrace"); + matchsymbol.put("lParen","rParen"); + matchsymbol.put("llparenthesis","rlparenthesis"); + matchsymbol.put("llangle","rlangle"); + matchsymbol.put("lbrackubar","rbrackubar"); + matchsymbol.put("lbrackultick","rbrackultick"); + matchsymbol.put("lbracklltick","rbracklltick"); + matchsymbol.put("langledot","rangledot"); + matchsymbol.put("lparenless","rparenless"); + matchsymbol.put("lparengtr","rparengtr"); + matchsymbol.put("lblkbrbrak","rblkbrbrak"); + matchsymbol.put("lvzigzag","rvzigzag"); + matchsymbol.put("Lvzigzag","Rvzigzag"); + matchsymbol.put("lcurvyangle","rcurvyangle"); + matchsymbol.put("lbrbrak","rbrbrak"); */ + + + symboltype.put("lparen",1); + symboltype.put("lbrack",1); + symboltype.put("lbrace",1); +/* symboltype.put("lceil",1); + symboltype.put("lfloor",1); + symboltype.put("ulcorner",1); + symboltype.put("llcorner",1); + symboltype.put("lbag",1); + symboltype.put("lBrack",1); + symboltype.put("langle",1); + symboltype.put("lAngle",1); + symboltype.put("Lbrbrak",1); + symboltype.put("lgroup",1); + symboltype.put("lBrace",1); + symboltype.put("lParen",1); + symboltype.put("llparenthesis",1); + symboltype.put("llangle",1); + symboltype.put("lbrackubar",1); + symboltype.put("lbrackultick",1); + symboltype.put("lbracklltick",1); + symboltype.put("langledot",1); + symboltype.put("lparenless",1); + symboltype.put("lparengtr",1); + symboltype.put("lblkbrbrak",1); + symboltype.put("lvzigzag",1); + symboltype.put("Lvzigzag",1); + symboltype.put("lcurvyangle",1); + symboltype.put("lbrbrak",1); */ + symboltype.put("rparen",2); + symboltype.put("rbrack",2); + symboltype.put("rbrace",2); +/* symboltype.put("rceil",2); + symboltype.put("rfloor",2); + symboltype.put("urcorner",2); + symboltype.put("lrcorner",2); + symboltype.put("rbag",2); + symboltype.put("rBrack",2); + symboltype.put("rangle",2); + symboltype.put("rAngle",2); + symboltype.put("Rbrbrak",2); + symboltype.put("rgroup",2); + symboltype.put("rBrace",2); + symboltype.put("rParen",2); + symboltype.put("rrparenthesis",2); + symboltype.put("rrangle",2); + symboltype.put("rbrackubar",2); + symboltype.put("rbrackurtick",2); + symboltype.put("rbracklrtick",2); + symboltype.put("rangledot",2); + symboltype.put("rparenless",2); + symboltype.put("rparengtr",2); + symboltype.put("rblkbrbrak",2); + symboltype.put("rvzigzag",2); + symboltype.put("Rvzigzag",2); + symboltype.put("rcurvyangle",2); + symboltype.put("rbrbrak",2); */ + symboltype.put("vert",3); + /* symboltype.put("Vert",3); + symboltype.put("Vvert",3); */ + + // symboltype.put("overbracket",5); + // symboltype.put("overparen",5); + symboltype.put("overbrace",5); + // symboltype.put("underbracket",6); + // symboltype.put("underparen",6); + symboltype.put("underbrace",6); + symboltype.put("grave",7); symbolsubtype.put("grave",1); + symboltype.put("acute",7); symbolsubtype.put("acute",1); + symboltype.put("hat",7); symbolsubtype.put("hat",1); + symboltype.put("tilde",7); symbolsubtype.put("tilde",1); + symboltype.put("overbar",7); symbolsubtype.put("overbar",1); + symboltype.put("breve",7); symbolsubtype.put("breve",1); + symboltype.put("dot",7); symbolsubtype.put("dot",1); +/* symboltype.put("ddot",7); symbolsubtype.put("ddot",1); + symboltype.put("ocirc",7); symbolsubtype.put("ocirc",1); + symboltype.put("check",7);symbolsubtype.put("check",1); + symboltype.put("not",7); symbolsubtype.put("not",1); + symboltype.put("leftharpoonaccent",7);symbolsubtype.put("leftharpoonaccent",2); + symboltype.put("rightharpoonaccent",7); symbolsubtype.put("rightharpoonaccent",2); + symboltype.put("vertoverlay",7); // cancel + symboltype.put("overleftarrow",7); symbolsubtype.put("overleftarrow",2); */ + symboltype.put("vec",7);symbolsubtype.put("vec",2); + symboltype.put("dddot",7); symbolsubtype.put("dddot",2); +/* symboltype.put("ddddot",7);symbolsubtype.put("ddddot",2); + symboltype.put("overleftrightarrow",7); symbolsubtype.put("overleftrightarrow",2); + symboltype.put("widebridgeabove",7); symbolsubtype.put("widebridgeabove",2); + symboltype.put("threeunderdot",8); + symboltype.put("underrightharpoondown",8); + symboltype.put("underleftharpoondown",8); + symboltype.put("underleftarrow",8); + symboltype.put("underrightarrow",8); */ + + symboltype.put("sqrt",9); + symboltype.put("cuberoot",9); + symboltype.put("fourthroot",9); + + symboltype.put("plus",10); + symboltype.put("pm",10); + /* symboltype.put("cdotp",10); + symboltype.put("times",10); + symboltype.put("div",10); + symboltype.put("dagger",10); + symboltype.put("ddagger",10); + symboltype.put("smblkcircle",10); + symboltype.put("tieconcat",10); + symboltype.put("fracslash",10); + symboltype.put("upand",10); + symboltype.put("minus",10); + symboltype.put("mp",10); + symboltype.put("dotplus",10); + symboltype.put("divslash",10); + symboltype.put("smallsetminus",10); + symboltype.put("ast",10); + symboltype.put("vysmwhtcircle",10); + symboltype.put("vysmblkcircle",10); + symboltype.put("wedge",10); + symboltype.put("vee",10); + symboltype.put("cap",10); + symboltype.put("cup",10); + symboltype.put("dotminus",10); + symboltype.put("invlazys",10); + symboltype.put("wr",10); + symboltype.put("cupleftarrow",10); + symboltype.put("cupdot",10); + symboltype.put("uplus",10); + symboltype.put("sqcap",10); + symboltype.put("sqcup",10); + symboltype.put("oplus",10); + symboltype.put("ominus",10); + symboltype.put("otimes",10); + symboltype.put("oslash",10); + symboltype.put("odot",10); + symboltype.put("circledcirc",10); + symboltype.put("circleddast",10); + symboltype.put("circledequal",10); + symboltype.put("circleddash",10); + symboltype.put("boxplus",10); + symboltype.put("boxminus",10); + symboltype.put("boxtimes",10); + symboltype.put("boxdot",10); + symboltype.put("intercal",10); + symboltype.put("veebar",10); + symboltype.put("barwedge",10); + symboltype.put("barvee",10); + symboltype.put("smwhtdiamond",10); */ + symboltype.put("cdot",10); + /* symboltype.put("star",10); + symboltype.put("divideontimes",10); + symboltype.put("ltimes",10); + symboltype.put("rtimes",10); + symboltype.put("leftthreetimes",10); + symboltype.put("rightthreetimes",10); + symboltype.put("curlyvee",10); + symboltype.put("curlywedge",10); + symboltype.put("Cap",10); + symboltype.put("Cup",10); + symboltype.put("varbarwedge",10); + symboltype.put("vardoublewedge",10); + symboltype.put("obar",10); + symboltype.put("bigtriangleup",10); + symboltype.put("triangleright",10); + symboltype.put("triangleleft",10); + symboltype.put("mdlgwhtcircle",10); + symboltype.put("boxbar",10); + symboltype.put("veedot",10); + symboltype.put("wedgedot",10); + symboltype.put("lozengeminus",10); + symboltype.put("concavediamond",10); + symboltype.put("concavediamondtickleft",10); + symboltype.put("concavediamondtickright",10); + symboltype.put("whitesquaretickleft",10); + symboltype.put("whitesquaretickright",10); + symboltype.put("typecolon",10); + symboltype.put("circlehbar",10); + symboltype.put("circledvert",10); + symboltype.put("circledparallel",10); + symboltype.put("obslash",10); + symboltype.put("operp",10); + symboltype.put("olessthan",10); + symboltype.put("ogreaterthan",10); + symboltype.put("boxdiag",10); + symboltype.put("boxbslash",10); + symboltype.put("boxast",10); + symboltype.put("boxcicle",10); + symboltype.put("boxbox",10); + symboltype.put("triangleserifs",10); + symboltype.put("hourglass",10); + symboltype.put("blackhourglass",10); + symboltype.put("shuffle",10); + symboltype.put("mdlgblkozenge",10); + symboltype.put("setminus",10); + symboltype.put("dsol",10); + symboltype.put("rsolbar",10); + symboltype.put("doubleplus",10); + symboltype.put("tripleplus",10); + symboltype.put("tplus",10); + symboltype.put("tminus",10); + symboltype.put("ringplus",10); + symboltype.put("plushat",10); + symboltype.put("simplus",10); + symboltype.put("plusdot",10); + symboltype.put("plussim",10); + symboltype.put("plussubtwo",10); + symboltype.put("plustrif",10); + symboltype.put("commaminus",10); + symboltype.put("minusdot",10); + symboltype.put("minusfdots",10); + symboltype.put("minusrdots",10); + symboltype.put("opluslhrim",10); + symboltype.put("oplusrhrim",10); + symboltype.put("vectimes",10); + symboltype.put("dottimes",10); + symboltype.put("timesbar",10); + symboltype.put("btimes",10); + symboltype.put("smashtimes",10); + symboltype.put("otimeslhrim",10); + symboltype.put("otimesrhrim",10); + symboltype.put("otimeshat",10); + symboltype.put("Otimes",10); + symboltype.put("odiv",10); + symboltype.put("triangleplus",10); + symboltype.put("triangleminus",10); + symboltype.put("triangletimes",10); + symboltype.put("intprod",10); + symboltype.put("intprodr",10); + symboltype.put("fcmp",10); + symboltype.put("amalg",10); + symboltype.put("capdot",10); + symboltype.put("barcup",10); + symboltype.put("barcap",10); + symboltype.put("capwedge",10); + symboltype.put("cupvee",10); + symboltype.put("cupovercap",10); + symboltype.put("cupovercup",10); + symboltype.put("cupbarcap",10); + symboltype.put("capbarcup",10); + symboltype.put("twocups",10); + symboltype.put("twocaps",10); + symboltype.put("closedvarcup",10); + symboltype.put("closedvarcap",10); + symboltype.put("Sqcap",10); + symboltype.put("Sqcup",10); + symboltype.put("closedvarcupsmashprod",10); + symboltype.put("wedgeodot",10); + symboltype.put("veeodot",10); + symboltype.put("Wedge",10); + symboltype.put("Vee",10); + symboltype.put("wedgeonwedge",10); + symboltype.put("veeonvee",10); + symboltype.put("bigslopedvee",10); + symboltype.put("bigslopedwedge",10); + symboltype.put("wedgemidvert",10); + symboltype.put("veemidvert",10); + symboltype.put("midbarwedge",10); + symboltype.put("midbarvee",10); + symboltype.put("doublebarwedge",10); + symboltype.put("wedgebar",10); + symboltype.put("wedgedoublebar",10); + symboltype.put("varveebar",10); + symboltype.put("doublebarvee",10); + symboltype.put("veedoublebar",10); + symboltype.put("dsub",10); + symboltype.put("rsub",10); + symboltype.put("eqqplus",10); + symboltype.put("pluseqq",10); + symboltype.put("interleave",10); + symboltype.put("nhVvert",10); + symboltype.put("threedotcolon",10); + symboltype.put("trslash",10); + symboltype.put("sslash",10); + symboltype.put("talloblong",10); */ +/* symboltype.put("octothorpe",11); + symboltype.put("mathdollar",11); + symboltype.put("percent",11); + symboltype.put("ampersand",11); + symboltype.put("period",11); + symboltype.put("mathslash",11); + symboltype.put("question",11); + symboltype.put("atsign",11); */ + symboltype.put("backslash",11); + /* symboltype.put("sterling",11); + symboltype.put("yen",11); + symboltype.put("neg",11); + symboltype.put("horizbar",11); + symboltype.put("twolowline",11); + symboltype.put("enleadertwodots",11); + symboltype.put("unicodeellipsis",11); + symboltype.put("prime",11); + symboltype.put("dprime",11); + symboltype.put("trprime",11); + symboltype.put("backprime",11); + symboltype.put("backdprime",11); + symboltype.put("backtrprime",11); + symboltype.put("Exclam",11); + symboltype.put("qprime",11); + symboltype.put("euro",11); + symboltype.put("enclosecircle",11); + symboltype.put("enclosesquare",11); + symboltype.put("enclosediamond",11); + symboltype.put("enclosetriangle",11); + symboltype.put("Eulerconst",11); + symboltype.put("Planckconst",11); + symboltype.put("mho",11); + symboltype.put("Finv",11); + symboltype.put("Bbbpi",11); + symboltype.put("Game",11); + symboltype.put("sansLturned",11); + symboltype.put("sansLmirrored",11); + symboltype.put("Yup",11); + symboltype.put("mitBbbD",11); + symboltype.put("mitBbbd",11); + symboltype.put("mitBbbe",11); + symboltype.put("mitBbbi",11); + symboltype.put("mitBbbj",11); + symboltype.put("updownarrowbar",11); + symboltype.put("linefeed",11); + symboltype.put("carriagereturn",11); + symboltype.put("barovernorthwestarrow",11); + symboltype.put("barleftarrowrightarrowbar",11); + symboltype.put("acwopencirclearrow",11); + symboltype.put("cwopencirclearrow",11); + symboltype.put("nHuparrow",11); + symboltype.put("nHdownarrow",11); + symboltype.put("leftdasharrow",11); + symboltype.put("updasharrow",11); + symboltype.put("rightdasharrow",11); + symboltype.put("downdasharrow",11); + symboltype.put("leftwhitearrow",11); + symboltype.put("upwhitearrow",11); + symboltype.put("rightwhitearrow",11); + symboltype.put("downwhitearrow",11); + symboltype.put("whitearrowupfrombar",11); */ + symboltype.put("forall",11); + symboltype.put("complement",11); + symboltype.put("exists",11); + symboltype.put("nexists",11); + symboltype.put("varnothing",11); + symboltype.put("increment",11); + symboltype.put("QED",11); + symboltype.put("infty",11); + symboltype.put("rightangle",11); + symboltype.put("angle",11); + symboltype.put("measuredangle",11); + symboltype.put("sphericalangle",11); + symboltype.put("therefore",11); + symboltype.put("because",11); +/* symboltype.put("sinewave",11); + symboltype.put("top",11); + symboltype.put("bot",11); + symboltype.put("hermitmatrix",11); + symboltype.put("measuredrightangle",11); + symboltype.put("varlrtriangle",11); + symboltype.put("unicodecdots",11); + symboltype.put("diameter",11); + symboltype.put("invnot",11); + symboltype.put("turnednot",11); + symboltype.put("inttop",11); + symboltype.put("intbottom",11); + symboltype.put("lparenuend",11); + symboltype.put("lparenextender",11); + symboltype.put("lparenlend",11); + symboltype.put("rparenuend",11); + symboltype.put("rparenextender",11); + symboltype.put("rparenlend",11); + symboltype.put("lbrackuend",11); + symboltype.put("lbrackextender",11); + symboltype.put("lbracklend",11); + symboltype.put("rbrackuend",11); + symboltype.put("rbrackextender",11); + symboltype.put("rbracklend",11); + symboltype.put("lbraceuend",11); + symboltype.put("lbracemid",11); + symboltype.put("lbracelend",11); + symboltype.put("vbraceextender",11); + symboltype.put("rbraceuend",11); + symboltype.put("rbracemid",11); + symboltype.put("rbracelend",11); + symboltype.put("intextender",11); + symboltype.put("harrowextender",11); + symboltype.put("sumtop",11); + symboltype.put("sumbottom",11); + symboltype.put("sqrtbottom",11); + symboltype.put("obrbrak",11); + symboltype.put("ubrbrak",11); + symboltype.put("blanksymbol",11); + symboltype.put("mathvisiblespace",11); + symboltype.put("mdlgblksquare",11); + symboltype.put("mdlgwhtsquare",11); + symboltype.put("bigblacktriangleup",11); + symboltype.put("blacktriangleright",11); + symboltype.put("blackpointerright",11); + symboltype.put("whitepointerright",11); + symboltype.put("bigblacktriangledown",11); + symboltype.put("bigtriangledown",11); + symboltype.put("blacktriangleleft",11); + symboltype.put("blackpointerleft",11); + symboltype.put("whitepointerleft",11); + symboltype.put("bullseye",11); + symboltype.put("mdlgblkcircle",11); + symboltype.put("smwhtcircle",11); + symboltype.put("squareleftblack",11); + symboltype.put("squarerightblack",11); + symboltype.put("mdwhtsquare",11); + symboltype.put("mdblksquare",11); + symboltype.put("bigstar",11); + symboltype.put("bigwhitestar",11); + symboltype.put("spadesuit",11); + symboltype.put("heartsuit",11); + symboltype.put("diamondsuit",11); + symboltype.put("clubsuit",11); + symboltype.put("varspadesuit",11); + symboltype.put("varheartsuit",11); + symboltype.put("vardiamondsuit",11); + symboltype.put("varclubsuit",11); + symboltype.put("quarternote",11); + symboltype.put("eighthnote",11); + symboltype.put("flat",11); + symboltype.put("natural",11); + symboltype.put("sharp",11); + symboltype.put("dicei",11); + symboltype.put("diceii",11); + symboltype.put("diceiii",11); + symboltype.put("diceiv",11); + symboltype.put("dicev",11); + symboltype.put("dicevi",11); + symboltype.put("checkmark",11); + symboltype.put("maltese",11); + symboltype.put("varstar",11); + symboltype.put("threedangle",11); + symboltype.put("whiteinwhitetriangle",11); + symboltype.put("subsetcirc",11); + symboltype.put("supsetcirc",11); + symboltype.put("diamondcdot",11); + symboltype.put("rdiagovfdiag",11); + symboltype.put("fdiagovrdiag",11); + symboltype.put("seovnearrow",11); + symboltype.put("neovsearrow",11); + symboltype.put("fdiagovnearrow",11); + symboltype.put("rdiagovsearrow",11); + symboltype.put("neovnwarrow",11); + symboltype.put("nwovnearrow",11); + symboltype.put("uprightcurvearrow",11); + symboltype.put("downrightcurvedarrow",11); + symboltype.put("mdsmblkcircle",11); + symboltype.put("fourvdots",11); + symboltype.put("vzigzag",11); + symboltype.put("measuredangleleft",11); + symboltype.put("rightanglesqr",11); + symboltype.put("rightanglemdot",11); + symboltype.put("angles",11); + symboltype.put("angdnr",11); + symboltype.put("gtlpar",11); + symboltype.put("sphericalangleup",11); + symboltype.put("turnangle",11); + symboltype.put("revangle",11); + symboltype.put("angleubar",11); + symboltype.put("revangleubar",11); + symboltype.put("wideangledown",11); + symboltype.put("wideangleup",11); + symboltype.put("measanglerutone",11); + symboltype.put("measanglelutonw",11); + symboltype.put("measanglerdtose",11); + symboltype.put("measangleldtosw",11); + symboltype.put("measangleurtone",11); + symboltype.put("measangleultonw",11); + symboltype.put("measangledrtose",11); + symboltype.put("measangledltosw",11); + symboltype.put("revemptyset",11); + symboltype.put("emptysetobar",11); + symboltype.put("emptysetocirc",11); + symboltype.put("emptysetoarr",11); + symboltype.put("emptysetoarrl",11); + symboltype.put("obot",11); + symboltype.put("olcross",11); + symboltype.put("odotslashdot",11); + symboltype.put("uparrowoncircle",11); + symboltype.put("circledwhitebullet",11); + symboltype.put("circledbullet",11); + symboltype.put("cirscir",11); + symboltype.put("cirE",11); + symboltype.put("boxonbox",11); + symboltype.put("triangleodot",11); + symboltype.put("triangleubar",11); + symboltype.put("triangles",11); + symboltype.put("iinfin",11); + symboltype.put("tieinfty",11); + symboltype.put("nvinfty",11); + symboltype.put("laplac",11); + symboltype.put("thermod",11); + symboltype.put("downtriangleleftblack",11); + symboltype.put("downtrianglerightblack",11); + symboltype.put("blackdiamonddownarrow",11); + symboltype.put("circledownarrow",11); + symboltype.put("blackcircledownarrow",11); + symboltype.put("errbarsquare",11); + symboltype.put("errbarblacksquare",11); + symboltype.put("errbardiamond",11); + symboltype.put("errbarblackdiamond",11); + symboltype.put("errbarcircle",11); + symboltype.put("errbarblackcircle",11); + symboltype.put("perps",11); + symboltype.put("topcir",11); + symboltype.put("dottedsquare",11); + symboltype.put("lgblksquare",11); + symboltype.put("lgwhtsquare",11); + symboltype.put("medwhitestar",11); + symboltype.put("medblackstar",11); + symboltype.put("smwhitestar",11); */ + symboltype.put("less",12); + symboltype.put("equal",12); + symboltype.put("greater",12); +/* symboltype.put("closure",12); + symboltype.put("leftarrow",12); + symboltype.put("uparrow",12); + symboltype.put("rightarrow",12); + symboltype.put("downarrow",12); + symboltype.put("leftrightarrow",12); + symboltype.put("updownarrow",12); + symboltype.put("nwarrow",12); + symboltype.put("nearrow",12); + symboltype.put("searrow",12); + symboltype.put("swarrow",12); + symboltype.put("nleftarrow",12); + symboltype.put("nrightarrow",12); + symboltype.put("leftwavearrow",12); + symboltype.put("rightwavearrow",12); + symboltype.put("twoheadleftarrow",12); + symboltype.put("twoheaduparrow",12); + symboltype.put("twoheadrightarrow",12); + symboltype.put("twoheaddownarrow",12); + symboltype.put("leftarrowtail",12); + symboltype.put("rightarrowtail",12); + symboltype.put("mapsfrom",12); + symboltype.put("mapsup",12); + symboltype.put("mapsto(",12); + symboltype.put("mapsdown",12); + symboltype.put("hookleftarrow",12); + symboltype.put("hookrightarrow",12); + symboltype.put("looparrowleft",12); + symboltype.put("looparrowright",12); + symboltype.put("leftrightsquigarrow",12); + symboltype.put("nleftrightarrow",12); + symboltype.put("downzigzagarrow",12); + symboltype.put("Lsh",12); + symboltype.put("Rsh",12); + symboltype.put("Ldsh",12); + symboltype.put("Rdsh",12); + symboltype.put("curvearrowleft",12); + symboltype.put("curvearrowright",12); + symboltype.put("leftharpoonup",12); + symboltype.put("leftharpoondown",12); + symboltype.put("upharpoonright",12); + symboltype.put("upharpoonleft",12); + symboltype.put("rightharpoonup",12); + symboltype.put("rightharpoondown",12); + symboltype.put("downharpoonright",12); + symboltype.put("downharpoonleft",12); + symboltype.put("rightleftarrows",12); + symboltype.put("updownarrows",12); + symboltype.put("leftrightarrows",12); + symboltype.put("leftleftarrows",12); + symboltype.put("upuparrows",12); + symboltype.put("rightrightarrows",12); + symboltype.put("downdownarrows",12); + symboltype.put("leftrightharpoons",12); + symboltype.put("rightleftharpoons",12); + symboltype.put("nLeftarrow",12); + symboltype.put("nLeftrightarrow",12); + symboltype.put("nRightarrow",12); + symboltype.put("Leftarrow",12); + symboltype.put("Uparrow",12); + symboltype.put("Rightarrow",12); + symboltype.put("Downarrow",12); + symboltype.put("Leftrightarrow",12); + symboltype.put("Updownarrow",12); + symboltype.put("Nwarrow",12); + symboltype.put("Nearrow",12); + symboltype.put("Searrow",12); + symboltype.put("Swarrow",12); + symboltype.put("Lleftarrow",12); + symboltype.put("Rrightarrow",12); + symboltype.put("leftsquigarrow",12); + symboltype.put("rightsquigarrow",12); + symboltype.put("barleftarrow",12); + symboltype.put("rightarrowbar",12); + symboltype.put("circleonrightarrow",12); + symboltype.put("downuparrows",12); + symboltype.put("rightthreearrows",12); + symboltype.put("nvleftarrow",12); + symboltype.put("nvrightarrow",12); + symboltype.put("nvleftrightarrow",12); + symboltype.put("nVleftarrow",12); + symboltype.put("nVrightarrow",12); + symboltype.put("nVleftrightarrow",12); + symboltype.put("leftarrowtriangle",12); + symboltype.put("rightarrowtriangle",12); + symboltype.put("leftrightarrowtriangle",12); + symboltype.put("in",12); + symboltype.put("notin",12); + symboltype.put("smallin",12); + symboltype.put("ni",12); + symboltype.put("nni",12); + symboltype.put("smallni",12); + symboltype.put("propto",12); + symboltype.put("mid",12); + symboltype.put("nmid",12); + symboltype.put("parallel",12); + symboltype.put("nparallel",12); + symboltype.put("mathratio",12); + symboltype.put("Colon",12); + symboltype.put("dashcolon",12); + symboltype.put("dotsminusdots",12); + symboltype.put("kernelcontraction",12); */ + symboltype.put("sim",12); +// symboltype.put("backsim",12); + symboltype.put("nsim",12); + symboltype.put("eqsim",12); + symboltype.put("simeq",12); + symboltype.put("nsime",12); + // symboltype.put("cong",12); + // symboltype.put("simneqq",12); + // symboltype.put("ncong",12); + symboltype.put("approx",12); + symboltype.put("napprox",12); + symboltype.put("approxeq",12); + /* symboltype.put("approxident",12); + symboltype.put("backcong",12); + symboltype.put("asymp",12); + symboltype.put("Bumpeq",12); + symboltype.put("bumpeq",12); + symboltype.put("doteq",12); + symboltype.put("Doteq",12); + symboltype.put("fallingdotseq",12); + symboltype.put("risingdotseq",12); + symboltype.put("coloneq",12); + symboltype.put("eqcolon",12); + symboltype.put("eqcirc",12); + symboltype.put("circeq",12); + symboltype.put("arceq",12); + symboltype.put("wedgeq",12); + symboltype.put("veeeq",12); + symboltype.put("stareq",12); + symboltype.put("triangleq",12); + symboltype.put("eqdef",12); + symboltype.put("measeq",12); + symboltype.put("questeq",12); */ + symboltype.put("ne",12); + symboltype.put("equiv",12); + symboltype.put("nequiv",12); + symboltype.put("Equiv",12); + symboltype.put("leq",12); + symboltype.put("geq",12); + symboltype.put("leqq",12); + symboltype.put("geqq",12); + symboltype.put("lneqq",12); + symboltype.put("gneqq",12); + symboltype.put("ll",12); + symboltype.put("gg",12); + /* symboltype.put("between",12); + symboltype.put("nasymp",12); + symboltype.put("nless",12); + symboltype.put("ngtr",12); + symboltype.put("nleq",12); + symboltype.put("ngeq",12); + symboltype.put("lesssim",12); + symboltype.put("gtrsim",12); + symboltype.put("nlesssim",12); + symboltype.put("ngtrsim",12); + symboltype.put("lessgtr",12); + symboltype.put("gtrless",12); + symboltype.put("nlessgtr",12); + symboltype.put("ngtrless",12); + symboltype.put("prec",12); + symboltype.put("succ",12); + symboltype.put("preccurlyeq",12); + symboltype.put("succcurlyeq",12); + symboltype.put("precsim",12); + symboltype.put("succsim",12); + symboltype.put("nprec",12); + symboltype.put("nsucc",12); + symboltype.put("subset",12); + symboltype.put("supset",12); + symboltype.put("nsubset",12); + symboltype.put("nsupset",12); + symboltype.put("subseteq",12); + symboltype.put("supseteq",12); + symboltype.put("nsubseteq",12); + symboltype.put("nsupseteq",12); + symboltype.put("subsetneq",12); + symboltype.put("supsetneq",12); + symboltype.put("sqsubset",12); + symboltype.put("sqsupset",12); + symboltype.put("sqsubseteq",12); + symboltype.put("sqsupseteq",12); + symboltype.put("vdash",12); + symboltype.put("dashv",12); + symboltype.put("assert",12); + symboltype.put("models",12); + symboltype.put("vDash",12); + symboltype.put("Vdash",12); + symboltype.put("Vvdash",12); + symboltype.put("VDash",12); + symboltype.put("nvdash",12); + symboltype.put("nvDash",12); + symboltype.put("nVdash",12); + symboltype.put("nVDash",12); + symboltype.put("prurel",12); + symboltype.put("scurel",12); + symboltype.put("vartriangleleft",12); + symboltype.put("vartriangleright",12); + symboltype.put("trianglelefteq",12); + symboltype.put("trianglerighteq",12); + symboltype.put("origof",12); + symboltype.put("imageof",12); + symboltype.put("multimap",12); + symboltype.put("bowtie",12); + symboltype.put("backsimeq",12); + symboltype.put("Subset",12); + symboltype.put("Supset",12); + symboltype.put("pitchfork",12); + symboltype.put("equalparallel",12); + symboltype.put("lessdot",12); + symboltype.put("gtrdot",12); + symboltype.put("lll",12); + symboltype.put("ggg",12); + symboltype.put("lesseqgtr",12); + symboltype.put("gtreqless",12); + symboltype.put("eqless",12); + symboltype.put("eqgtr",12); + symboltype.put("curlyeqprec",12); + symboltype.put("curlyeqsucc",12); + symboltype.put("npreccurlyeq",12); + symboltype.put("nsucccurlyeq",12); + symboltype.put("nsqsubseteq",12); + symboltype.put("nsqsupseteq",12); + symboltype.put("sqsubsetneq",12); + symboltype.put("sqsupsetneq",12); + symboltype.put("lnsim",12); + symboltype.put("gnsim",12); + symboltype.put("precnsim",12); + symboltype.put("succnsim",12); + symboltype.put("nvartriangleleft",12); + symboltype.put("nvartriangleright",12); + symboltype.put("ntrianglelefteq",12); + symboltype.put("ntrianglerighteq",12); + symboltype.put("vdots",12); + symboltype.put("adots",12); + symboltype.put("ddots",12); + symboltype.put("disin",12); + symboltype.put("varisins",12); + symboltype.put("isins",12); + symboltype.put("isindot",12); + symboltype.put("varisinobar",12); + symboltype.put("isinobar",12); + symboltype.put("isinvb",12); + symboltype.put("isinE",12); + symboltype.put("nisd",12); + symboltype.put("varnis",12); + symboltype.put("nis",12); + symboltype.put("varniobar",12); + symboltype.put("niobar",12); + symboltype.put("bagmember",12); + symboltype.put("frown",12); + symboltype.put("smile",12); + symboltype.put("perp",12); + symboltype.put("bsolhsub",12); + symboltype.put("suphsol",12); + symboltype.put("upin",12); + symboltype.put("pullback",12); + symboltype.put("pushout",12); + symboltype.put("DashVDash",12); + symboltype.put("dashVdash",12); + symboltype.put("multimapinv",12); + symboltype.put("vlongdash",12); + symboltype.put("longdashv",12); + symboltype.put("cirbot",12); + symboltype.put("UUparrow",12); + symboltype.put("DDownarrow",12); + symboltype.put("acwgapcirclearrow",12); + symboltype.put("cwgapcirclearrow",12); + symboltype.put("rightarrowonoplus",12); + symboltype.put("longleftarrow",12); + symboltype.put("longrightarrow",12); + symboltype.put("longleftrightarrow",12); + symboltype.put("Longleftarrow",12); + symboltype.put("Longrightarrow",12); + symboltype.put("Longleftrightarrow",12); + symboltype.put("longmapsfrom",12); + symboltype.put("longmapsto",12); + symboltype.put("Longmapsfrom",12); + symboltype.put("Longmapsto",12); + symboltype.put("longrightsquigarrow",12); + symboltype.put("nvtwoheadrightarrow",12); + symboltype.put("nVtwoheadrightarrow",12); + symboltype.put("nvLeftarrow",12); + symboltype.put("nvRightarrow",12); + symboltype.put("nvLeftrightarrow",12); + symboltype.put("twoheadmapsto",12); + symboltype.put("Mapsfrom",12); + symboltype.put("Mapsto",12); + symboltype.put("downarrowbarred",12); + symboltype.put("uparrowbarred",12); + symboltype.put("Uuparrow",12); + symboltype.put("Ddownarrow",12); + symboltype.put("leftbkarrow",12); + symboltype.put("rightbkarrow",12); + symboltype.put("leftdbkarrow",12); + symboltype.put("dbkarow",12); + symboltype.put("drbkarow",12); + symboltype.put("rightdotarrow",12); + symboltype.put("baruparrow",12); + symboltype.put("downarrowbar",12); + symboltype.put("nvrightarrowtail",12); + symboltype.put("nVrightarrowtail",12); + symboltype.put("twoheadrightarrowtail",12); + symboltype.put("nvtwoheadrightarrowtail",12); + symboltype.put("nVtwoheadrightarrowtail",12); + symboltype.put("lefttail",12); + symboltype.put("righttail",12); + symboltype.put("leftdbltail",12); + symboltype.put("rightdbltail",12); + symboltype.put("diamondleftarrow",12); + symboltype.put("rightarrowdiamond",12); + symboltype.put("diamondleftarrowbar",12); + symboltype.put("barrightarrowdiamond",12); + symboltype.put("nwsearrow",12); + symboltype.put("neswarrow",12); + symboltype.put("hknwarrow",12); + symboltype.put("hknearrow",12); + symboltype.put("hksearow",12); + symboltype.put("hkswarow",12); + symboltype.put("tona",12); + symboltype.put("toea",12); + symboltype.put("tosa",12); + symboltype.put("towa",12); + symboltype.put("rightcurvedarrow",12); + symboltype.put("leftdowncurvedarrow",12); + symboltype.put("rightdowncurvedarrow",12); + symboltype.put("cwrightarcarrow",12); + symboltype.put("acwleftarcarrow",12); + symboltype.put("acwoverarcarrow",12); + symboltype.put("acwunderarcarrow",12); + symboltype.put("curvearrowrightminus",12); + symboltype.put("curvearrowleftplus",12); + symboltype.put("cwundercurvearrow",12); + symboltype.put("ccwundercurvearrow",12); + symboltype.put("acwcirclearrow",12); + symboltype.put("cwcirclearrow",12); + symboltype.put("rightarrowshortleftarrow",12); + symboltype.put("leftarrowshortrightarrow",12); + symboltype.put("shortrightarrowleftarrow",12); + symboltype.put("rightarrowplus",12); + symboltype.put("leftarrowplus",12); + symboltype.put("rightarrowx",12); + symboltype.put("leftrightarrowcircle",12); + symboltype.put("twoheaduparrowcircle",12); + symboltype.put("leftrightharpoonupdown",12); + symboltype.put("leftrightharpoondownup",12); + symboltype.put("updownharpoonrightleft",12); + symboltype.put("updownharpoonleftright",12); + symboltype.put("leftrightharpoonupup",12); + symboltype.put("updownharpoonrightright",12); + symboltype.put("leftrightharpoondowndown",12); + symboltype.put("updownharpoonleftleft",12); + symboltype.put("barleftharpoonup",12); + symboltype.put("rightharpoonupbar",12); + symboltype.put("barupharpoonright",12); + symboltype.put("downharpoonrightbar",12); + symboltype.put("barleftharpoondown",12); + symboltype.put("rightharpoondownbar",12); + symboltype.put("barupharpoonleft",12); + symboltype.put("downharpoonleftbar",12); + symboltype.put("leftharpoonupbar",12); + symboltype.put("barrightharpoonup",12); + symboltype.put("upharpoonrightbar",12); + symboltype.put("bardownharpoonright",12); + symboltype.put("leftharpoondownbar",12); + symboltype.put("barrightharpoondown",12); + symboltype.put("upharpoonleftbar",12); + symboltype.put("bardownharpoonleft",12); + symboltype.put("leftharpoonsupdown",12); + symboltype.put("upharpoonsleftright",12); + symboltype.put("rightharpoonsupdown",12); + symboltype.put("downharpoonsleftright",12); + symboltype.put("leftrightharpoonsup",12); + symboltype.put("leftrightharpoonsdown",12); + symboltype.put("rightleftharpoonsup",12); + symboltype.put("rightleftharpoonsdown",12); + symboltype.put("leftharpoonupdash",12); + symboltype.put("dashleftharpoondown",12); + symboltype.put("rightharpoonupdash",12); + symboltype.put("dashrightharpoondown",12); + symboltype.put("updownharpoonsleftright",12); + symboltype.put("downupharpoonsleftright",12); + symboltype.put("rightimply",12); + symboltype.put("equalrightarrow",12); + symboltype.put("similarrightarrow",12); + symboltype.put("leftarrowsimilar",12); + symboltype.put("rightarrowsimilar",12); + symboltype.put("rightarrowapprox",12); + symboltype.put("ltlarr",12); + symboltype.put("leftarrowless",12); + symboltype.put("gtrarr",12); + symboltype.put("subrarr",12); + symboltype.put("leftarrowsubset",12); + symboltype.put("suplarr",12); + symboltype.put("leftfishtail",12); + symboltype.put("rightfishtail",12); + symboltype.put("upfishtail",12); + symboltype.put("downfishtail",12); + symboltype.put("rtriltri",12); + symboltype.put("ltrivb",12); + symboltype.put("vbrtri",12); + symboltype.put("lfbowtie",12); + symboltype.put("rfbowtie",12); + symboltype.put("fbowtie",12); + symboltype.put("lftimes",12); + symboltype.put("rftimes",12); + symboltype.put("dualmap",12); + symboltype.put("lrtriangleeq",12); + symboltype.put("eparsl",12); + symboltype.put("smeparsl",12); + symboltype.put("eqvparsl",12); + symboltype.put("gleichstark",12); + symboltype.put("ruledelayed",12); + symboltype.put("veeonwedge",12); + symboltype.put("eqdot",12); + symboltype.put("dotequiv",12); + symboltype.put("equivVert",12); + symboltype.put("equivVvert",12); + symboltype.put("dotsim",12); + symboltype.put("simrdots",12); + symboltype.put("simminussim",12); + symboltype.put("congdot",12); + symboltype.put("asteq",12); + symboltype.put("hatapprox",12); + symboltype.put("approxeqq",12); + symboltype.put("eqqsim",12); + symboltype.put("Coloneq",12); + symboltype.put("eqeq",12); + symboltype.put("eqeqeq",12); + symboltype.put("ddotseq",12); + symboltype.put("equivDD",12); + symboltype.put("ltcir",12); + symboltype.put("gtcir",12); + symboltype.put("ltquest",12); + symboltype.put("gtquest",12); + symboltype.put("leqslant",12); + symboltype.put("geqslant",12); + symboltype.put("lesdot",12); + symboltype.put("gesdot",12); + symboltype.put("lesdoto",12); + symboltype.put("gesdoto",12); + symboltype.put("lesdotor",12); + symboltype.put("gesdotol",12); + symboltype.put("lessapprox",12); + symboltype.put("gtrapprox",12); + symboltype.put("lneq",12); + symboltype.put("gneq",12); + symboltype.put("lnapprox",12); + symboltype.put("gnapprox",12); + symboltype.put("lesseqqgtr",12); + symboltype.put("gtreqqless",12); + symboltype.put("lsime",12); + symboltype.put("gsime",12); + symboltype.put("lsimg",12); + symboltype.put("gsiml",12); + symboltype.put("lgE",12); + symboltype.put("glE",12); + symboltype.put("lesges",12); + symboltype.put("gesles",12); + symboltype.put("eqslantless",12); + symboltype.put("eqslantgtr",12); + symboltype.put("elsdot",12); + symboltype.put("egsdot",12); + symboltype.put("eqqless",12); + symboltype.put("eqqgtr",12); + symboltype.put("eqqslantless",12); + symboltype.put("eqqslantgtr",12); + symboltype.put("simless",12); + symboltype.put("simgtr",12); + symboltype.put("simlE",12); + symboltype.put("simgE",12); + symboltype.put("Lt",12); + symboltype.put("Gt",12); + symboltype.put("partialmeetcontraction",12); + symboltype.put("glj",12); + symboltype.put("gla",12); + symboltype.put("ltcc",12); + symboltype.put("gtcc",12); + symboltype.put("lescc",12); + symboltype.put("gescc",12); + symboltype.put("smt",12); + symboltype.put("lat",12); + symboltype.put("smte",12); + symboltype.put("late",12); + symboltype.put("bumpeqq",12); + symboltype.put("preceq",12); + symboltype.put("succeq",12); + symboltype.put("precneq",12); + symboltype.put("succneq",12); + symboltype.put("preceqq",12); + symboltype.put("succeqq",12); + symboltype.put("precneqq",12); + symboltype.put("succneqq",12); + symboltype.put("precapprox",12); + symboltype.put("succapprox",12); + symboltype.put("precnapprox",12); + symboltype.put("succnapprox",12); + symboltype.put("Prec",12); + symboltype.put("Succ",12); + symboltype.put("subsetdot",12); + symboltype.put("supsetdot",12); + symboltype.put("subsetplus",12); + symboltype.put("supsetplus",12); + symboltype.put("submult",12); + symboltype.put("supmult",12); + symboltype.put("subedot",12); + symboltype.put("supedot",12); + symboltype.put("subseteqq",12); + symboltype.put("supseteqq",12); + symboltype.put("subsim",12); + symboltype.put("supsim",12); + symboltype.put("subsetapprox",12); + symboltype.put("supsetapprox",12); + symboltype.put("subsetneqq",12); + symboltype.put("supsetneqq",12); + symboltype.put("lsqhook",12); + symboltype.put("rsqhook",12); + symboltype.put("csub",12); + symboltype.put("csup",12); + symboltype.put("csube",12); + symboltype.put("csupe",12); + symboltype.put("subsup",12); + symboltype.put("supsub",12); + symboltype.put("subsub",12); + symboltype.put("supsup",12); + symboltype.put("suphsub",12); + symboltype.put("supdsub",12); + symboltype.put("forkv",12); + symboltype.put("topfork",12); + symboltype.put("mlcp",12); + symboltype.put("forks",12); + symboltype.put("forksnot",12); + symboltype.put("shortlefttack",12); + symboltype.put("shortdowntack",12); + symboltype.put("shortuptack",12); + symboltype.put("vDdash",12); + symboltype.put("dashV",12); + symboltype.put("Dashv",12); + symboltype.put("DashV",12); + symboltype.put("varVdash",12); + symboltype.put("Barv",12); + symboltype.put("vBar",12); + symboltype.put("vBarv",12); + symboltype.put("barV",12); + symboltype.put("Vbar",12); + symboltype.put("Not",12); + symboltype.put("bNot",12); + symboltype.put("revnmid",12); + symboltype.put("cirmid",12); + symboltype.put("midcir",12); + symboltype.put("nhpar",12); + symboltype.put("parsim",12); + symboltype.put("lllnest",12); + symboltype.put("gggnest",12); + symboltype.put("leqqslant",12); + symboltype.put("geqqslant",12); + symboltype.put("circleonleftarrow",12); + symboltype.put("leftthreearrows",12); + symboltype.put("leftarrowonoplus",12); + symboltype.put("longleftsquigarrow",12); + symboltype.put("nvtwoheadleftarrow",12); + symboltype.put("nVtwoheadleftarrow",12); + symboltype.put("twoheadmapsfrom",12); + symboltype.put("twoheadleftdbkarrow",12); + symboltype.put("leftdotarrow",12); + symboltype.put("nvleftarrowtail",12); + symboltype.put("nVleftarrowtail",12); + symboltype.put("twoheadleftarrowtail",12); + symboltype.put("nvtwoheadleftarrowtail",12); + symboltype.put("nVtwoheadleftarrowtail",12); + symboltype.put("leftarrowx",12); + symboltype.put("leftcurvedarrow",12); + symboltype.put("equalleftarrow",12); + symboltype.put("bsimilarleftarrow",12); + symboltype.put("leftarrowbackapprox",12); + symboltype.put("rightarrowgtr",12); + symboltype.put("rightarrowsupset",12); + symboltype.put("LLeftarrow",12); + symboltype.put("RRightarrow",12); + symboltype.put("bsimilarrightarrow",12); + symboltype.put("rightarrowbackapprox",12); + symboltype.put("similarleftarrow",12); + symboltype.put("leftarrowapprox",12); + symboltype.put("leftarrowbsimilar",12); + symboltype.put("rightarrowbsimilar",12); */ + symboltype.put("Alpha",13); + symboltype.put("Beta",13); + symboltype.put("Gamma",13); + symboltype.put("Delta",13); + symboltype.put("Epsilon",13); + symboltype.put("Zeta",13); + symboltype.put("Eta",13); + symboltype.put("Theta",13); + symboltype.put("Iota",13); + symboltype.put("Kappa",13); + symboltype.put("Lambda",13); + symboltype.put("Mu",13); + symboltype.put("Nu",13); + symboltype.put("Xi",13); + symboltype.put("Omicron",13); + symboltype.put("Pi",13); + symboltype.put("Rho",13); + symboltype.put("Sigma",13); + symboltype.put("Tau",13); + symboltype.put("Upsilon",13); + symboltype.put("Phi",13); + symboltype.put("Chi",13); + symboltype.put("Psi",13); + symboltype.put("Omega",13); + symboltype.put("alpha",13); + symboltype.put("beta",13); + symboltype.put("gamma",13); + symboltype.put("delta",13); + symboltype.put("epsilon",13); + symboltype.put("zeta",13); + symboltype.put("eta",13); + symboltype.put("theta",13); + symboltype.put("iota",13); + symboltype.put("kappa",13); + symboltype.put("lambda",13); + symboltype.put("mu",13); + symboltype.put("nu",13); + symboltype.put("xi",13); + symboltype.put("omicron",13); + symboltype.put("pi",13); + symboltype.put("rho",13); + symboltype.put("varsigma",13); + symboltype.put("sigma",13); + symboltype.put("tau",13); + symboltype.put("upsilon",13); + symboltype.put("varphi",13); + symboltype.put("chi",13); + symboltype.put("psi",13); + symboltype.put("omega",13); + symboltype.put("varbeta",13); + symboltype.put("vartheta",13); + symboltype.put("phi",13); + symboltype.put("varpi",13); + symboltype.put("Digamma",13); + symboltype.put("digamma",13); + symboltype.put("varkappa",13); + symboltype.put("varrho",13); + symboltype.put("varTheta",13); + symboltype.put("varepsilon",13); +/* symboltype.put("matheth",13); + symboltype.put("BbbC",13); + symboltype.put("mscrg",13); + symboltype.put("mscrH",13); + symboltype.put("mfrakH",13); + symboltype.put("BbbH",13); + symboltype.put("hslash",13); + symboltype.put("mscrI",13); */ + symboltype.put("Im",13); +/* symboltype.put("mscrL",13); + symboltype.put("ell",13); + symboltype.put("BbbN",13); + symboltype.put("wp",13); + symboltype.put("BbbP",13); + symboltype.put("BbbQ",13); + symboltype.put("mscrR",13); */ + symboltype.put("Re",13); +/* symboltype.put("BbbR",13); + symboltype.put("BbbZ",13); + symboltype.put("mfrakZ",13); + symboltype.put("turnediota",13); + symboltype.put("Angstrom",13); + symboltype.put("mscrB",13); + symboltype.put("mfrakC",13); + symboltype.put("mscre",13); + symboltype.put("mscrE",13); + symboltype.put("mscrF",13); + symboltype.put("mscrM",13); + symboltype.put("mscro",13); + symboltype.put("aleph",13); + symboltype.put("beth",13); + symboltype.put("gimel",13); + symboltype.put("daleth",13); + symboltype.put("Bbbgamma",13); + symboltype.put("BbbGamma",13); + symboltype.put("BbbPi",13); */ + symboltype.put("partial",13); + symboltype.put("nabla",13); + symboltype.put("log",14); + symboltype.put("ln",14); + symboltype.put("sin",14); + symboltype.put("cos",14); + symboltype.put("tan",14); + symboltype.put("sec",14); + symboltype.put("csc",14); + symboltype.put("cot",14); + symboltype.put("sinh",14); + symboltype.put("cosh",14); + symboltype.put("tanh",14); + symboltype.put("coth",14); + symboltype.put("sech",14); + symboltype.put("csch",14); + symboltype.put("lim",15); + + symboltype.put("exclam",17); + symboltype.put("comma",17); + // symboltype.put("mathcolon",17); + // symboltype.put("semicolon",17); + + // symboltype.put("Bbbsum",19); + symboltype.put("prod",19); + // symboltype.put("coprod",19); + symboltype.put("sum",19); + /* symboltype.put("intclockwise",19); + symboltype.put("varointclockwise",19); + symboltype.put("ointctrclockwise",19); + symboltype.put("bigwedge",19); + symboltype.put("bigvee",19); + symboltype.put("bigcap",19); + symboltype.put("bigcup",19); + symboltype.put("leftouterjoin",19); + symboltype.put("rightouterjoin",19); + symboltype.put("fullouterjoin",19); + symboltype.put("bigbot",19); + symboltype.put("bigtop",19); + symboltype.put("xsol",19); + symboltype.put("xbsol",19); + symboltype.put("bigodot",19); + symboltype.put("bigoplus",19); + symboltype.put("bigotimes",19); + symboltype.put("bigcupdot",19); + symboltype.put("biguplus",19); + symboltype.put("bigsqcap",19); + symboltype.put("bigsqcup",19); + symboltype.put("conjquant",19); + symboltype.put("disjquant",19); + symboltype.put("bigtimes",19); + symboltype.put("modtwosum",19); + symboltype.put("intbar",19); + symboltype.put("intBar",19); + symboltype.put("intlarhk",19); + symboltype.put("intx",19); + symboltype.put("intcap",19); + symboltype.put("intcup",19); + symboltype.put("Join",19); + symboltype.put("bigtriangleleft",19); + symboltype.put("zcmp",19); + symboltype.put("zpipe",19); + symboltype.put("zproject",19); + symboltype.put("biginterleave",19); + symboltype.put("bigtalloblong",19); */ + + +// symboltype.put("bigBbbsum",20); + symboltype.put("bigprod",20); +// symboltype.put("bigcoprod",20); + symboltype.put("bigsum",20); + /* symboltype.put("bigintclockwise",20); + symboltype.put("bigvarointclockwise",20); + symboltype.put("bigointctrclockwise",20); + symboltype.put("bigbigwedge",20); + symboltype.put("bigbigvee",20); + symboltype.put("bigbigcap",20); + symboltype.put("bigbigcup",20); + symboltype.put("bigleftouterjoin",20); + symboltype.put("bigrightouterjoin",20); + symboltype.put("bigfullouterjoin",20); + symboltype.put("bigbigbot",20); + symboltype.put("bigbigtop",20); + symboltype.put("bigxsol",20); + symboltype.put("bigxbsol",20); + symboltype.put("bigbigodot",20); + symboltype.put("bigbigoplus",20); + symboltype.put("bigbigotimes",20); + symboltype.put("bigbigcupdot",20); + symboltype.put("bigbiguplus",20); + symboltype.put("bigbigsqcap",20); + symboltype.put("bigbigsqcup",20); + symboltype.put("bigconjquant",20); + symboltype.put("bigdisjquant",20); + symboltype.put("bigbigtimes",20); + symboltype.put("bigmodtwosum",20); + symboltype.put("bigintbar",20); + symboltype.put("bigintBar",20); + symboltype.put("bigintlarhk",20); + symboltype.put("bigintx",20); + symboltype.put("bigintcap",20); + symboltype.put("bigintcup",20); + symboltype.put("bigJoin",20); + symboltype.put("bigbigtriangleleft",20); + symboltype.put("bigzcmp",20); + symboltype.put("bigzpipe",20); + symboltype.put("bigzproject",20); + symboltype.put("bigbiginterleave",20); + symboltype.put("bigbigtalloblong",20); */ + +// symboltype.put("bigbigBbbsum",21); + symboltype.put("bigbigprod",21); + // symboltype.put("bigbigcoprod",21); + symboltype.put("bigbigsum",21); + /* symboltype.put("bigbigintclockwise",21); + symboltype.put("bigbigvarointclockwise",21); + symboltype.put("bigbigointctrclockwise",21); + symboltype.put("bigbigbigwedge",21); + symboltype.put("bigbigbigvee",21); + symboltype.put("bigbigbigcap",21); + symboltype.put("bigbigbigcup",21); + symboltype.put("bigbigleftouterjoin",21); + symboltype.put("bigbigrightouterjoin",21); + symboltype.put("bigbigfullouterjoin",21); + symboltype.put("bigbigbigbot",21); + symboltype.put("bigbigbigtop",21); + symboltype.put("bigbigxsol",21); + symboltype.put("bigbigxbsol",21); + symboltype.put("bigbigbigodot",21); + symboltype.put("bigbigbigoplus",21); + symboltype.put("bigbigbigotimes",21); + symboltype.put("bigbigbigcupdot",21); + symboltype.put("bigbigbiguplus",21); + symboltype.put("bigbigbigsqcap",21); + symboltype.put("bigbigbigsqcup",21); + symboltype.put("bigbigconjquant",21); + symboltype.put("bigbigdisjquant",21); + symboltype.put("bigbigbigtimes",21); + symboltype.put("bigbigmodtwosum",21); + symboltype.put("bigbigintbar",21); + symboltype.put("bigbigintBar",21); + symboltype.put("bigbigintlarhk",21); + symboltype.put("bigbigintx",21); + symboltype.put("bigbigintcap",21); + symboltype.put("bigbigintcup",21); + symboltype.put("bigbigJoin",21); + symboltype.put("bigbigbigtriangleleft",21); + symboltype.put("bigbigzcmp",21); + symboltype.put("bigbigzpipe",21); + symboltype.put("bigbigzproject",21); + symboltype.put("bigbigbiginterleave",21); + symboltype.put("bigbigbigtalloblong",21); */ + + symboltype.put("int",22); + symboltype.put("iint",22); + symboltype.put("iiint",22); + symboltype.put("oint",22); + symboltype.put("oiint",22); + symboltype.put("oiiint",22); + /* symboltype.put("sumint",22); + symboltype.put("iiiint",22); + symboltype.put("fint",22); + symboltype.put("cirfint",22); + symboltype.put("awint",22); + symboltype.put("rppolint",22); + symboltype.put("scpolint",22); + symboltype.put("npolint",22); + symboltype.put("pointint",22); + symboltype.put("sqint",22); + symboltype.put("upint",22); + symboltype.put("lowint",22); */ + + + symboltype.put("bigint",23); + symboltype.put("bigiint",23); + symboltype.put("bigiiint",23); + symboltype.put("bigoint",23); + symboltype.put("bigoiint",23); + symboltype.put("bigoiiint",23); + /* symboltype.put("bigsumint",23); + symboltype.put("bigiiiint",23); + symboltype.put("bigfint",23); + symboltype.put("bigcirfint",23); + symboltype.put("bigawint",23); + symboltype.put("bigrppolint",23); + symboltype.put("bigscpolint",23); + symboltype.put("bignpolint",23); + symboltype.put("bigpointint",23); + symboltype.put("bigsqint",23); + symboltype.put("bigupint",23); + symboltype.put("biglowint",23); */ + + symboltype.put("bigbigint",24); + symboltype.put("bigbigiint",24); + symboltype.put("bigbigiiint",24); + symboltype.put("bigbigoint",24); + symboltype.put("bigbigoiint",24); + symboltype.put("bigbigoiiint",24); + /* symboltype.put("bigbigsumint",24); + symboltype.put("bigbigiiiint",24); + symboltype.put("bigbigfint",24); + symboltype.put("bigbigcirfint",24); + symboltype.put("bigbigawint",24); + symboltype.put("bigbigrppolint",24); + symboltype.put("bigbigscpolint",24); + symboltype.put("bigbignpolint",24); + symboltype.put("bigbigpointint",24); + symboltype.put("bigbigsqint",24); + symboltype.put("bigbigupint",24); + symboltype.put("bigbiglowint",24); */ + +/************************************************************************************/ + + symbolunicode.put("lparen","\u0028"); + symbolunicode.put("lbrack","\u005B"); + symbolunicode.put("lbrace","\u007B"); +/* symbolunicode.put("lceil","\u2308"); + symbolunicode.put("lfloor","\u230A"); + symbolunicode.put("ulcorner","\u231C"); + symbolunicode.put("llcorner","\u231E"); + symbolunicode.put("lbag","\u27C5"); + symbolunicode.put("lBrack","\u27E6"); + symbolunicode.put("langle","\u27E8"); + symbolunicode.put("lAngle","\u27EA"); + symbolunicode.put("Lbrbrak","\u27EC"); + symbolunicode.put("lgroup","\u27EE"); + symbolunicode.put("lBrace","\u2983"); + symbolunicode.put("lParen","\u2985"); + symbolunicode.put("llparenthesis","\u2987"); + symbolunicode.put("llangle","\u2989"); + symbolunicode.put("lbrackubar","\u298B"); + symbolunicode.put("lbrackultick","\u298D"); + symbolunicode.put("lbracklltick","\u298F"); + symbolunicode.put("langledot","\u2991"); + symbolunicode.put("lparenless","\u2993"); + symbolunicode.put("lparengtr","\u2995"); + symbolunicode.put("lblkbrbrak","\u2997"); + symbolunicode.put("lvzigzag","\u29D8"); + symbolunicode.put("Lvzigzag","\u29DA"); + symbolunicode.put("lcurvyangle","\u29FC"); + symbolunicode.put("lbrbrak","\u3014"); */ + symbolunicode.put("rparen","\u0029"); + symbolunicode.put("rbrack","\u005D"); + symbolunicode.put("rbrace","\u007D"); +/* symbolunicode.put("rceil","\u2309"); + symbolunicode.put("rfloor","\u230B"); + symbolunicode.put("urcorner","\u231D"); + symbolunicode.put("lrcorner","\u231F"); + symbolunicode.put("rbag","\u27C6"); + symbolunicode.put("rBrack","\u27E7"); + symbolunicode.put("rangle","\u27E9"); + symbolunicode.put("rAngle","\u27EB"); + symbolunicode.put("Rbrbrak","\u27ED"); + symbolunicode.put("rgroup","\u27EF"); + symbolunicode.put("rBrace","\u2984"); + symbolunicode.put("rParen","\u2986"); + symbolunicode.put("rrparenthesis","\u2988"); + symbolunicode.put("rrangle","\u298A"); + symbolunicode.put("rbrackubar","\u298C"); + symbolunicode.put("rbrackurtick","\u2990"); + symbolunicode.put("rbracklrtick","\u298E"); + symbolunicode.put("rangledot","\u2992"); + symbolunicode.put("rparenless","\u2996"); + symbolunicode.put("rparengtr","\u2994"); + symbolunicode.put("rblkbrbrak","\u2998"); + symbolunicode.put("rvzigzag","\u29D9"); + symbolunicode.put("Rvzigzag","\u29DB"); + symbolunicode.put("rcurvyangle","\u29FD"); + symbolunicode.put("rbrbrak","\u3015"); */ + symbolunicode.put("vert","\u007C"); + /* symbolunicode.put("Vert","\u2016"); + symbolunicode.put("Vvert","\u2980"); */ + symbolunicode.put("exclam","\u0021"); + /* symbolunicode.put("comma","\u002C"); + symbolunicode.put("mathcolon","\u003A"); + symbolunicode.put("semicolon","\u003B"); + symbolunicode.put("overbracket","\u23B4"); + symbolunicode.put("overparen","\u23DC"); */ + symbolunicode.put("overbrace","\u23DE"); + // symbolunicode.put("underbracket","\u23B5"); + // symbolunicode.put("underparen","\u23DD"); + symbolunicode.put("underbrace","\u23DF"); + symbolunicode.put("grave","\u0300"); + symbolunicode.put("acute","\u0301"); + symbolunicode.put("hat","\u0302"); + symbolunicode.put("tilde","\u0303"); + symbolunicode.put("bar","\u0304"); + symbolunicode.put("overbar","\u0305"); + symbolunicode.put("breve","\u0306"); + symbolunicode.put("dot","\u0307"); + /* symbolunicode.put("ddot","\u0308"); + symbolunicode.put("ovhook","\u0309"); + symbolunicode.put("ocirc","\u030A"); + symbolunicode.put("check","\u030C"); + symbolunicode.put("not","\u0338"); + symbolunicode.put("leftharpoonaccent","\u20D0"); + symbolunicode.put("rightharpoonaccent","\u20D1"); + symbolunicode.put("vertoverlay","\u20D2"); + symbolunicode.put("overleftarrow","\u20D6"); */ + symbolunicode.put("vec","\u20D7"); + symbolunicode.put("dddot","\u20DB"); + /* symbolunicode.put("ddddot","\u20DC"); + symbolunicode.put("overleftrightarrow","\u20E1"); + symbolunicode.put("annuity","\u20E7"); + symbolunicode.put("widebridgeabove","\u20E9"); + symbolunicode.put("threeunderdot","\u20E8"); + symbolunicode.put("underrightharpoondown","\u20EC"); + symbolunicode.put("underleftharpoondown","\u20ED"); + symbolunicode.put("underleftarrow","\u20EE"); + symbolunicode.put("underrightarrow","\u20EF");*/ + // symbolunicode.put("Bbbsum","\u2140"); + symbolunicode.put("prod","\u220F"); + // symbolunicode.put("coprod","\u2210"); + symbolunicode.put("sum","\u2211"); + symbolunicode.put("int","\u222B"); + symbolunicode.put("iint","\u222C"); + symbolunicode.put("iiint","\u222D"); + symbolunicode.put("oint","\u222E"); + symbolunicode.put("oiint","\u222F"); + symbolunicode.put("oiiint","\u2230"); + /* symbolunicode.put("intclockwise","\u2231"); + symbolunicode.put("varointclockwise","\u2232"); + symbolunicode.put("ointctrclockwise","\u2233"); + symbolunicode.put("bigwedge","\u22C0"); + symbolunicode.put("bigvee","\u22C1"); + symbolunicode.put("bigcap","\u22C2"); + symbolunicode.put("bigcup","\u22C3"); + symbolunicode.put("leftouterjoin","\u27D5"); + symbolunicode.put("rightouterjoin","\u27D6"); + symbolunicode.put("fullouterjoin","\u27D7"); + symbolunicode.put("bigbot","\u27D8"); + symbolunicode.put("bigtop","\u27D9"); + symbolunicode.put("xsol","\u29F8"); + symbolunicode.put("xbsol","\u29F9"); + symbolunicode.put("bigodot","\u2A00"); + symbolunicode.put("bigoplus","\u2A01"); + symbolunicode.put("bigotimes","\u2A02"); + symbolunicode.put("bigcupdot","\u2A03"); + symbolunicode.put("biguplus","\u2A04"); + symbolunicode.put("bigsqcap","\u2A05"); + symbolunicode.put("bigsqcup","\u2A06"); + symbolunicode.put("conjquant","\u2A07"); + symbolunicode.put("disjquant","\u2A08"); + symbolunicode.put("bigtimes","\u2A09"); + symbolunicode.put("modtwosum","\u2A0A"); + symbolunicode.put("sumint","\u2A0B"); + symbolunicode.put("iiiint","\u2A0C"); + symbolunicode.put("intbar","\u2A0D"); + symbolunicode.put("intBar","\u2A0E"); + symbolunicode.put("fint","\u2A0F"); + symbolunicode.put("cirfint","\u2A10"); + symbolunicode.put("awint","\u2A11"); + symbolunicode.put("rppolint","\u2A12"); + symbolunicode.put("scpolint","\u2A13"); + symbolunicode.put("npolint","\u2A14"); + symbolunicode.put("pointint","\u2A15"); + symbolunicode.put("sqint","\u2A16"); + symbolunicode.put("intlarhk","\u2A17"); + symbolunicode.put("intx","\u2A18"); + symbolunicode.put("intcap","\u2A19"); + symbolunicode.put("intcup","\u2A1A"); + symbolunicode.put("upint","\u2A1B"); + symbolunicode.put("lowint","\u2A1C"); + symbolunicode.put("Join","\u2A1D"); + symbolunicode.put("bigtriangleleft","\u2A1E"); + symbolunicode.put("zcmp","\u2A1F"); + symbolunicode.put("zpipe","\u2A20"); + symbolunicode.put("zproject","\u2A21"); + symbolunicode.put("biginterleave","\u2AFc"); + symbolunicode.put("bigtalloblong","\u2AFF"); */ + // symbolunicode.put("bigBbbsum","\u2140"); + symbolunicode.put("bigprod","\u220F"); + // symbolunicode.put("bigcoprod","\u2210"); + symbolunicode.put("bigsum","\u2211"); + symbolunicode.put("bigint","\u222B"); + symbolunicode.put("bigiint","\u222C"); + symbolunicode.put("bigiiint","\u222D"); + symbolunicode.put("bigoint","\u222E"); + symbolunicode.put("bigoiint","\u222F"); + symbolunicode.put("bigoiiint","\u2230"); + /* symbolunicode.put("bigintclockwise","\u2231"); + symbolunicode.put("bigvarointclockwise","\u2232"); + symbolunicode.put("bigointctrclockwise","\u2233"); + symbolunicode.put("bigbigwedge","\u22C0"); + symbolunicode.put("bigbigvee","\u22C1"); + symbolunicode.put("bigbigcap","\u22C2"); + symbolunicode.put("bigbigcup","\u22C3"); + symbolunicode.put("bigleftouterjoin","\u27D5"); + symbolunicode.put("bigrightouterjoin","\u27D6"); + symbolunicode.put("bigfullouterjoin","\u27D7"); + symbolunicode.put("bigbigbot","\u27D8"); + symbolunicode.put("bigbigtop","\u27D9"); + symbolunicode.put("bigxsol","\u29F8"); + symbolunicode.put("bigxbsol","\u29F9"); + symbolunicode.put("bigbigodot","\u2A00"); + symbolunicode.put("bigbigoplus","\u2A01"); + symbolunicode.put("bigbigotimes","\u2A02"); + symbolunicode.put("bigbigcupdot","\u2A03"); + symbolunicode.put("bigbiguplus","\u2A04"); + symbolunicode.put("bigbigsqcap","\u2A05"); + symbolunicode.put("bigbigsqcup","\u2A06"); + symbolunicode.put("bigconjquant","\u2A07"); + symbolunicode.put("bigdisjquant","\u2A08"); + symbolunicode.put("bigbigtimes","\u2A09"); + symbolunicode.put("bigmodtwosum","\u2A0A"); + symbolunicode.put("bigsumint","\u2A0B"); + symbolunicode.put("bigiiiint","\u2A0C"); + symbolunicode.put("bigintbar","\u2A0D"); + symbolunicode.put("bigintBar","\u2A0E"); + symbolunicode.put("bigfint","\u2A0F"); + symbolunicode.put("bigcirfint","\u2A10"); + symbolunicode.put("bigawint","\u2A11"); + symbolunicode.put("bigrppolint","\u2A12"); + symbolunicode.put("bigscpolint","\u2A13"); + symbolunicode.put("bignpolint","\u2A14"); + symbolunicode.put("bigpointint","\u2A15"); + symbolunicode.put("bigsqint","\u2A16"); + symbolunicode.put("bigintlarhk","\u2A17"); + symbolunicode.put("bigintx","\u2A18"); + symbolunicode.put("bigintcap","\u2A19"); + symbolunicode.put("bigintcup","\u2A1A"); + symbolunicode.put("bigupint","\u2A1B"); + symbolunicode.put("biglowint","\u2A1C"); + symbolunicode.put("bigJoin","\u2A1D"); + symbolunicode.put("bigbigtriangleleft","\u2A1E"); + symbolunicode.put("bigzcmp","\u2A1F"); + symbolunicode.put("bigzpipe","\u2A20"); + symbolunicode.put("bigzproject","\u2A21"); + symbolunicode.put("bigbiginterleave","\u2AFc"); + symbolunicode.put("bigbigtalloblong","\u2AFF"); */ + // symbolunicode.put("bigbigBbbsum","\u2140"); + symbolunicode.put("bigbigprod","\u220F"); + // symbolunicode.put("bigbigcoprod","\u2210"); + symbolunicode.put("bigbigsum","\u2211"); + symbolunicode.put("bigbigint","\u222B"); + symbolunicode.put("bigbigiint","\u222C"); + symbolunicode.put("bigbigiiint","\u222D"); + symbolunicode.put("bigbigoint","\u222E"); + symbolunicode.put("bigbigoiint","\u222F"); + symbolunicode.put("bigbigoiiint","\u2230"); +/* symbolunicode.put("bigbigintclockwise","\u2231"); + symbolunicode.put("bigbigvarointclockwise","\u2232"); + symbolunicode.put("bigbigointctrclockwise","\u2233"); + symbolunicode.put("bigbigbigwedge","\u22C0"); + symbolunicode.put("bigbigbigvee","\u22C1"); + symbolunicode.put("bigbigbigcap","\u22C2"); + symbolunicode.put("bigbigbigcup","\u22C3"); + symbolunicode.put("bigbigleftouterjoin","\u27D5"); + symbolunicode.put("bigbigrightouterjoin","\u27D6"); + symbolunicode.put("bigbigfullouterjoin","\u27D7"); + symbolunicode.put("bigbigbigbot","\u27D8"); + symbolunicode.put("bigbigbigtop","\u27D9"); + symbolunicode.put("bigbigxsol","\u29F8"); + symbolunicode.put("bigbigxbsol","\u29F9"); + symbolunicode.put("bigbigbigodot","\u2A00"); + symbolunicode.put("bigbigbigoplus","\u2A01"); + symbolunicode.put("bigbigbigotimes","\u2A02"); + symbolunicode.put("bigbigbigcupdot","\u2A03"); + symbolunicode.put("bigbigbiguplus","\u2A04"); + symbolunicode.put("bigbigbigsqcap","\u2A05"); + symbolunicode.put("bigbigbigsqcup","\u2A06"); + symbolunicode.put("bigbigconjquant","\u2A07"); + symbolunicode.put("bigbigdisjquant","\u2A08"); + symbolunicode.put("bigbigbigtimes","\u2A09"); + symbolunicode.put("bigbigmodtwosum","\u2A0A"); + symbolunicode.put("bigbigsumint","\u2A0B"); + symbolunicode.put("bigbigiiiint","\u2A0C"); + symbolunicode.put("bigbigintbar","\u2A0D"); + symbolunicode.put("bigbigintBar","\u2A0E"); + symbolunicode.put("bigbigfint","\u2A0F"); + symbolunicode.put("bigbigcirfint","\u2A10"); + symbolunicode.put("bigbigawint","\u2A11"); + symbolunicode.put("bigbigrppolint","\u2A12"); + symbolunicode.put("bigbigscpolint","\u2A13"); + symbolunicode.put("bigbignpolint","\u2A14"); + symbolunicode.put("bigbigpointint","\u2A15"); + symbolunicode.put("bigbigsqint","\u2A16"); + symbolunicode.put("bigbigintlarhk","\u2A17"); + symbolunicode.put("bigbigintx","\u2A18"); + symbolunicode.put("bigbigintcap","\u2A19"); + symbolunicode.put("bigbigintcup","\u2A1A"); + symbolunicode.put("bigbigupint","\u2A1B"); + symbolunicode.put("bigbiglowint","\u2A1C"); + symbolunicode.put("bigbigJoin","\u2A1D"); + symbolunicode.put("bigbigbigtriangleleft","\u2A1E"); + symbolunicode.put("bigbigzcmp","\u2A1F"); + symbolunicode.put("bigbigzpipe","\u2A20"); + symbolunicode.put("bigbigzproject","\u2A21"); + symbolunicode.put("bigbigbiginterleave","\u2AFc"); + symbolunicode.put("bigbigbigtalloblong","\u2AFF"); */ + + symbolunicode.put("plus","\u002B"); + symbolunicode.put("pm","\u00B1"); + /* symbolunicode.put("cdotp","\u00B7"); + symbolunicode.put("times","\u00D7"); + symbolunicode.put("div","\u00F7"); + symbolunicode.put("dagger","\u2020"); + symbolunicode.put("ddagger","\u2021"); + symbolunicode.put("smblkcircle","\u2022"); + symbolunicode.put("tieconcat","\u2040"); + symbolunicode.put("fracslash","\u2044"); + symbolunicode.put("upand","\u214B"); + symbolunicode.put("minus","\u2212"); + symbolunicode.put("mp","\u2213"); + symbolunicode.put("dotplus","\u2214"); + symbolunicode.put("divslash","\u2215"); + symbolunicode.put("smallsetminus","\u2216"); + symbolunicode.put("ast","\u2217"); + symbolunicode.put("vysmwhtcircle","\u2218"); + symbolunicode.put("vysmblkcircle","\u2219"); + symbolunicode.put("wedge","\u2227"); + symbolunicode.put("vee","\u2228"); + symbolunicode.put("cap","\u2229"); + symbolunicode.put("cup","\u222A"); + symbolunicode.put("dotminus","\u2238"); + symbolunicode.put("invlazys","\u223E"); + symbolunicode.put("wr","\u2240"); + symbolunicode.put("cupleftarrow","\u228C"); + symbolunicode.put("cupdot","\u228D"); + symbolunicode.put("uplus","\u228E"); + symbolunicode.put("sqcap","\u2293"); + symbolunicode.put("sqcup","\u2294"); + symbolunicode.put("oplus","\u2295"); + symbolunicode.put("ominus","\u2296"); + symbolunicode.put("otimes","\u2297"); + symbolunicode.put("oslash","\u2298"); + symbolunicode.put("odot","\u2299"); + symbolunicode.put("circledcirc","\u229A"); + symbolunicode.put("circleddast","\u229B"); + symbolunicode.put("circledequal","\u229C"); + symbolunicode.put("circleddash","\u229D"); + symbolunicode.put("boxplus","\u229E"); + symbolunicode.put("boxminus","\u229F"); + symbolunicode.put("boxtimes","\u22A0"); + symbolunicode.put("boxdot","\u22A1"); + symbolunicode.put("intercal","\u22BA"); + symbolunicode.put("veebar","\u22BB"); + symbolunicode.put("barwedge","\u22BC"); + symbolunicode.put("barvee","\u22BD"); + symbolunicode.put("smwhtdiamond","\u22C4"); */ + symbolunicode.put("cdot","\u22C5"); + /* symbolunicode.put("star","\u22C6"); + symbolunicode.put("divideontimes","\u22C7"); + symbolunicode.put("ltimes","\u22C9"); + symbolunicode.put("rtimes","\u22CA"); + symbolunicode.put("leftthreetimes","\u22CB"); + symbolunicode.put("rightthreetimes","\u22CC"); + symbolunicode.put("curlyvee","\u22CE"); + symbolunicode.put("curlywedge","\u22CF"); + symbolunicode.put("Cap","\u22D2"); + symbolunicode.put("Cup","\u22D3"); + symbolunicode.put("varbarwedge","\u2305"); + symbolunicode.put("vardoublewedge","\u2306"); + symbolunicode.put("obar","\u233D"); + symbolunicode.put("bigtriangleup","\u25B3"); + symbolunicode.put("triangleright","\u25B7"); + symbolunicode.put("triangleleft","\u25C1"); + symbolunicode.put("mdlgwhtcircle","\u25CB"); + symbolunicode.put("boxbar","\u25EB"); + symbolunicode.put("veedot","\u27C7"); + symbolunicode.put("wedgedot","\u27D1"); + symbolunicode.put("lozengeminus","\u27E0"); + symbolunicode.put("concavediamond","\u27E1"); + symbolunicode.put("concavediamondtickleft","\u27E2"); + symbolunicode.put("concavediamondtickright","\u27E3"); + symbolunicode.put("whitesquaretickleft","\u27E4"); + symbolunicode.put("whitesquaretickright","\u27E5"); + symbolunicode.put("typecolon","\u2982"); + symbolunicode.put("circlehbar","\u29B5"); + symbolunicode.put("circledvert","\u29B6"); + symbolunicode.put("circledparallel","\u29B7"); + symbolunicode.put("obslash","\u29B8"); + symbolunicode.put("operp","\u29B9"); + symbolunicode.put("olessthan","\u29C0"); + symbolunicode.put("ogreaterthan","\u29C1"); + symbolunicode.put("boxdiag","\u29C4"); + symbolunicode.put("boxbslash","\u29C5"); + symbolunicode.put("boxast","\u29C6"); + symbolunicode.put("boxcicle","\u29C7"); + symbolunicode.put("boxbox","\u29C8"); + symbolunicode.put("triangleserifs","\u29CD"); + symbolunicode.put("hourglass","\u29D6"); + symbolunicode.put("blackhourglass","\u29D7"); + symbolunicode.put("shuffle","\u29E2"); + symbolunicode.put("mdlgblkozenge","\u29EB"); + symbolunicode.put("setminus","\u29F5"); + symbolunicode.put("dsol","\u29F6"); + symbolunicode.put("rsolbar","\u29F7"); + symbolunicode.put("doubleplus","\u29FA"); + symbolunicode.put("tripleplus","\u29FB"); + symbolunicode.put("tplus","\u29FE"); + symbolunicode.put("tminus","\u29FF"); + symbolunicode.put("ringplus","\u2A22"); + symbolunicode.put("plushat","\u2A23"); + symbolunicode.put("simplus","\u2A24"); + symbolunicode.put("plusdot","\u2A25"); + symbolunicode.put("plussim","\u2A26"); + symbolunicode.put("plussubtwo","\u2A27"); + symbolunicode.put("plustrif","\u2A28"); + symbolunicode.put("commaminus","\u2A29"); + symbolunicode.put("minusdot","\u2A2A"); + symbolunicode.put("minusfdots","\u2A2B"); + symbolunicode.put("minusrdots","\u2A2C"); + symbolunicode.put("opluslhrim","\u2A2D"); + symbolunicode.put("oplusrhrim","\u2A2E"); + symbolunicode.put("vectimes","\u2A2F"); + symbolunicode.put("dottimes","\u2A30"); + symbolunicode.put("timesbar","\u2A31"); + symbolunicode.put("btimes","\u2A32"); + symbolunicode.put("smashtimes","\u2A33"); + symbolunicode.put("otimeslhrim","\u2A34"); + symbolunicode.put("otimesrhrim","\u2A35"); + symbolunicode.put("otimeshat","\u2A36"); + symbolunicode.put("Otimes","\u2A37"); + symbolunicode.put("odiv","\u2A38"); + symbolunicode.put("triangleplus","\u2A39"); + symbolunicode.put("triangleminus","\u2A3A"); + symbolunicode.put("triangletimes","\u2A3B"); + symbolunicode.put("intprod","\u2A3C"); + symbolunicode.put("intprodr","\u2A3D"); + symbolunicode.put("fcmp","\u2A3E"); + symbolunicode.put("amalg","\u2A3F"); + symbolunicode.put("capdot","\u2A40"); + symbolunicode.put("barcup","\u2A42"); + symbolunicode.put("barcap","\u2A43"); + symbolunicode.put("capwedge","\u2A44"); + symbolunicode.put("cupvee","\u2A45"); + symbolunicode.put("cupovercap","\u2A46"); + symbolunicode.put("cupovercup","\u2A47"); + symbolunicode.put("cupbarcap","\u2A48"); + symbolunicode.put("capbarcup","\u2A49"); + symbolunicode.put("twocups","\u2A4A"); + symbolunicode.put("twocaps","\u2A4B"); + symbolunicode.put("closedvarcup","\u2A4C"); + symbolunicode.put("closedvarcap","\u2A4D"); + symbolunicode.put("Sqcap","\u2A4E"); + symbolunicode.put("Sqcup","\u2A4F"); + symbolunicode.put("closedvarcupsmashprod","\u2A50"); + symbolunicode.put("wedgeodot","\u2A51"); + symbolunicode.put("veeodot","\u2A52"); + symbolunicode.put("Wedge","\u2A53"); + symbolunicode.put("Vee","\u2A54"); + symbolunicode.put("wedgeonwedge","\u2A55"); + symbolunicode.put("veeonvee","\u2A56"); + symbolunicode.put("bigslopedvee","\u2A57"); + symbolunicode.put("bigslopedwedge","\u2A58"); + symbolunicode.put("wedgemidvert","\u2A5A"); + symbolunicode.put("veemidvert","\u2A5B"); + symbolunicode.put("midbarwedge","\u2A5C"); + symbolunicode.put("midbarvee","\u2A5D"); + symbolunicode.put("doublebarwedge","\u2A5E"); + symbolunicode.put("wedgebar","\u2A5F"); + symbolunicode.put("wedgedoublebar","\u2A60"); + symbolunicode.put("varveebar","\u2A61"); + symbolunicode.put("doublebarvee","\u2A62"); + symbolunicode.put("veedoublebar","\u2A63"); + symbolunicode.put("dsub","\u2A64"); + symbolunicode.put("rsub","\u2A65"); + symbolunicode.put("eqqplus","\u2A71"); + symbolunicode.put("pluseqq","\u2A72"); + symbolunicode.put("interleave","\u2AF4"); + symbolunicode.put("nhVvert","\u2AF5"); + symbolunicode.put("threedotcolon","\u2AF6"); + symbolunicode.put("trslash","\u2AFB"); + symbolunicode.put("sslash","\u2AFD"); + symbolunicode.put("talloblong","\u2AFE");*/ +/* symbolunicode.put("octothrope", "\u0023"); + symbolunicode.put("mathdollar","\u0024"); + symbolunicode.put("percent","\u0025"); + symbolunicode.put("ampersand","\u0026"); + symbolunicode.put("period","\u002E"); + symbolunicode.put("mathslash","\u002F"); + symbolunicode.put("question","\u003F"); + symbolunicode.put("atsign","\u0040");*/ + symbolunicode.put("backslash","\\"); + /* symbolunicode.put("sterling","\u00A3"); + symbolunicode.put("yen","\u00A5"); + symbolunicode.put("neg","\u00AC"); + symbolunicode.put("horizbar","\u2015"); + symbolunicode.put("twolowline","\u2017"); + symbolunicode.put("enleadertwodots","\u2025"); + symbolunicode.put("unicodeellipsis","\u2026"); + symbolunicode.put("prime","\u2032"); + symbolunicode.put("dprime","\u2033"); + symbolunicode.put("trprime","\u2034"); + symbolunicode.put("backprime","\u2035"); + symbolunicode.put("backdprime","\u2036"); + symbolunicode.put("backtrprime","\u2037"); + symbolunicode.put("Exclam","\u203C"); + symbolunicode.put("qprime","\u2057"); + symbolunicode.put("euro","\u20AC"); + symbolunicode.put("enclosecircle","\u20DD"); + symbolunicode.put("enclosesquare","\u20DE"); + symbolunicode.put("enclosediamond","\u20DF"); + symbolunicode.put("enclosetriangle","\u20E4"); + symbolunicode.put("Eulerconst","\u2017"); + symbolunicode.put("Planckconst","\u210E"); + symbolunicode.put("mho","\u2127"); + symbolunicode.put("Finv","\u2132"); + symbolunicode.put("Bbbpi","\u213C"); + symbolunicode.put("Game","\u2141"); + symbolunicode.put("sansLturned","\u2142"); + symbolunicode.put("sansLmirrored","\u2143"); + symbolunicode.put("Yup","\u2144"); + symbolunicode.put("mitBbbD","\u2145"); + symbolunicode.put("mitBbbd","\u2146"); + symbolunicode.put("mitBbbe","\u2147"); + symbolunicode.put("mitBbbi","\u2148"); + symbolunicode.put("mitBbbj","\u2149"); + symbolunicode.put("updownarrowbar","\u21A8"); + symbolunicode.put("linefeed","\u21B4"); + symbolunicode.put("carriagereturn","\u21B5"); + symbolunicode.put("barovernorthwestarrow","\u21B8"); + symbolunicode.put("barleftarrowrightarrowbar","\u21B9"); + symbolunicode.put("acwopencirclearrow","\u21BA"); + symbolunicode.put("cwopencirclearrow","\u21BB"); + symbolunicode.put("nHuparrow","\u21DE"); + symbolunicode.put("nHdownarrow","\u21DF"); + symbolunicode.put("leftdasharrow","\u21E0"); + symbolunicode.put("updasharrow","\u21E1"); + symbolunicode.put("rightdasharrow","\u21E2"); + symbolunicode.put("downdasharrow","\u21E3"); + symbolunicode.put("leftwhitearrow","\u21E6"); + symbolunicode.put("upwhitearrow","\u21E7"); + symbolunicode.put("rightwhitearrow","\u21E8"); + symbolunicode.put("downwhitearrow","\u21E9"); + symbolunicode.put("whitearrowupfrombar","\u21EA"); */ + symbolunicode.put("forall","\u2200"); + symbolunicode.put("complement","\u2201"); + symbolunicode.put("exists","\u2203"); + symbolunicode.put("nexists","\u2204"); + symbolunicode.put("varnothing","\u2205"); + symbolunicode.put("increment","\u2206"); + symbolunicode.put("QED","\u220E"); + symbolunicode.put("infty","\u221E"); + symbolunicode.put("rightangle","\u221F"); + symbolunicode.put("angle","\u2220"); + symbolunicode.put("measuredangle","\u2221"); + symbolunicode.put("sphericalangle","\u2222"); + symbolunicode.put("therefore","\u2234"); + symbolunicode.put("because","\u2235"); + /* symbolunicode.put("sinewave","\u223F"); + symbolunicode.put("top","\u22A4"); + symbolunicode.put("bot","\u22A5"); + symbolunicode.put("hermitmatrix","\u22B9"); + symbolunicode.put("measuredrightangle","\u22BE"); + symbolunicode.put("varlrtriangle","\u22BF"); + symbolunicode.put("unicodecdots","\u22EF"); + symbolunicode.put("diameter","\u2300"); + symbolunicode.put("invnot","\u2310"); + symbolunicode.put("turnednot","\u2319"); + symbolunicode.put("inttop","\u2320"); + symbolunicode.put("intbottom","\u2321"); + symbolunicode.put("lparenuend","\u239B"); + symbolunicode.put("lparenextender","\u239C"); + symbolunicode.put("lparenlend","\u239D"); + symbolunicode.put("rparenuend","\u239E"); + symbolunicode.put("rparenextender","\u239F"); + symbolunicode.put("rparenlend","\u23A0"); + symbolunicode.put("lbrackuend","\u23A1"); + symbolunicode.put("lbrackextender","\u23A2"); + symbolunicode.put("lbracklend","\u23A3"); + symbolunicode.put("rbrackuend","\u23A4"); + symbolunicode.put("rbrackextender","\u23A5"); + symbolunicode.put("rbracklend","\u23A6"); + symbolunicode.put("lbraceuend","\u23A7"); + symbolunicode.put("lbracemid","\u23A8"); + symbolunicode.put("lbracelend","\u23A9"); + symbolunicode.put("vbraceextender","\u23AA"); + symbolunicode.put("rbraceuend","\u23AB"); + symbolunicode.put("rbracemid","\u23AC"); + symbolunicode.put("rbracelend","\u23AD"); + symbolunicode.put("intextender","\u23AE"); + symbolunicode.put("harrowextender","\u23AF"); + symbolunicode.put("sumtop","\u23B2"); + symbolunicode.put("sumbottom","\u23B3"); + symbolunicode.put("sqrtbottom","\u23B7"); + symbolunicode.put("obrbrak","\u23E0"); + symbolunicode.put("ubrbrak","\u23E1"); + symbolunicode.put("blanksymbol","\u2422"); + symbolunicode.put("mathvisiblespace","\u2423"); + symbolunicode.put("mdlgblksquare","\u25A0"); + symbolunicode.put("mdlgwhtsquare","\u25A1"); + symbolunicode.put("bigblacktriangleup","\u25B2"); + symbolunicode.put("blacktriangleright","\u25B6"); + symbolunicode.put("blackpointerright","\u25BA"); + symbolunicode.put("whitepointerright","\u25BB"); + symbolunicode.put("bigblacktriangledown","\u25BC"); + symbolunicode.put("bigtriangledown","\u25BD"); + symbolunicode.put("blacktriangleleft","\u25C0"); + symbolunicode.put("blackpointerleft","\u25C4"); + symbolunicode.put("whitepointerleft","\u25C5"); + symbolunicode.put("bullseye","\u25CE"); + symbolunicode.put("mdlgblkcircle","\u25CF"); + symbolunicode.put("smwhtcircle","\u25E6"); + symbolunicode.put("squareleftblack","\u25E7"); + symbolunicode.put("squarerightblack","\u25E8"); + symbolunicode.put("mdwhtsquare","\u25FB"); + symbolunicode.put("mdblksquare","\u25FC"); + symbolunicode.put("bigstar","\u2605"); + symbolunicode.put("bigwhitestar","\u2606"); + symbolunicode.put("spadesuit","\u2660"); + symbolunicode.put("heartsuit","\u2661"); + symbolunicode.put("diamondsuit","\u2662"); + symbolunicode.put("clubsuit","\u2663"); + symbolunicode.put("varspadesuit","\u2664"); + symbolunicode.put("varheartsuit","\u2665"); + symbolunicode.put("vardiamondsuit","\u2666"); + symbolunicode.put("varclubsuit","\u2667"); + symbolunicode.put("quarternote","\u2669"); + symbolunicode.put("eighthnote","\u266A"); + symbolunicode.put("flat","\u266D"); + symbolunicode.put("natural","\u266E"); + symbolunicode.put("sharp","\u266F"); + symbolunicode.put("dicei","\u2680"); + symbolunicode.put("diceii","\u2681"); + symbolunicode.put("diceiii","\u2682"); + symbolunicode.put("diceiv","\u2683"); + symbolunicode.put("dicev","\u2684"); + symbolunicode.put("dicevi","\u2685"); + symbolunicode.put("checkmark","\u2713"); + symbolunicode.put("maltese","\u2720"); + symbolunicode.put("varstar","\u2736"); + symbolunicode.put("threedangle","\u27C0"); + symbolunicode.put("whiteinwhitetriangle","\u27C1"); + symbolunicode.put("subsetcirc","\u27C3"); + symbolunicode.put("supsetcirc","\u27C4"); + symbolunicode.put("diamondcdot","\u27D0"); + symbolunicode.put("rdiagovfdiag","\u292B"); + symbolunicode.put("fdiagovrdiag","\u292C"); + symbolunicode.put("seovnearrow","\u292D"); + symbolunicode.put("neovsearrow","\u292E"); + symbolunicode.put("fdiagovnearrow","\u292F"); + symbolunicode.put("rdiagovsearrow","\u2930"); + symbolunicode.put("neovnwarrow","\u2931"); + symbolunicode.put("nwovnearrow","\u2932"); + symbolunicode.put("uprightcurvearrow","\u2934"); + symbolunicode.put("downrightcurvedarrow","\u2935"); + symbolunicode.put("mdsmblkcircle","\u2981"); + symbolunicode.put("fourvdots","\u2999"); + symbolunicode.put("vzigzag","\u299A"); + symbolunicode.put("measuredangleleft","\u299B"); + symbolunicode.put("rightanglesqr","\u299C"); + symbolunicode.put("rightanglemdot","\u299D"); + symbolunicode.put("angles","\u299E"); + symbolunicode.put("angdnr","\u299F"); + symbolunicode.put("gtlpar","\u29A0"); + symbolunicode.put("sphericalangleup","\u29A1"); + symbolunicode.put("turnangle","\u29A2"); + symbolunicode.put("revangle","\u29A3"); + symbolunicode.put("angleubar","\u29A4"); + symbolunicode.put("revangleubar","\u29A5"); + symbolunicode.put("wideangledown","\u29A6"); + symbolunicode.put("wideangleup","\u29A7"); + symbolunicode.put("measanglerutone","\u29A8"); + symbolunicode.put("measanglelutonw","\u29A9"); + symbolunicode.put("measanglerdtose","\u29AA"); + symbolunicode.put("measangleldtosw","\u29AB"); + symbolunicode.put("measangleurtone","\u29AC"); + symbolunicode.put("measangleultonw","\u29AD"); + symbolunicode.put("measangledrtose","\u29AE"); + symbolunicode.put("measangledltosw","\u29AF"); + symbolunicode.put("revemptyset","\u29B0"); + symbolunicode.put("emptysetobar","\u29B1"); + symbolunicode.put("emptysetocirc","\u29B2"); + symbolunicode.put("emptysetoarr","\u29B3"); + symbolunicode.put("emptysetoarrl","\u29B4"); + symbolunicode.put("obot","\u29BA"); + symbolunicode.put("olcross","\u29BB"); + symbolunicode.put("odotslashdot","\u29BC"); + symbolunicode.put("uparrowoncircle","\u29BD"); + symbolunicode.put("circledwhitebullet","\u29BE"); + symbolunicode.put("circledbullet","\u29BF"); + symbolunicode.put("cirscir","\u29C2"); + symbolunicode.put("cirE","\u29C3"); + symbolunicode.put("boxonbox","\u29C9"); + symbolunicode.put("triangleodot","\u29CA"); + symbolunicode.put("triangleubar","\u29CB"); + symbolunicode.put("triangles","\u29CC"); + symbolunicode.put("iinfin","\u29DC"); + symbolunicode.put("tieinfty","\u29DD"); + symbolunicode.put("nvinfty","\u29DE"); + symbolunicode.put("laplac","\u29E0"); + symbolunicode.put("thermod","\u29E7"); + symbolunicode.put("downtriangleleftblack","\u29E8"); + symbolunicode.put("downtrianglerightblack","\u29E9"); + symbolunicode.put("blackdiamonddownarrow","\u29EA"); + symbolunicode.put("circledownarrow","\u29EC"); + symbolunicode.put("blackcircledownarrow","\u29ED"); + symbolunicode.put("errbarsquare","\u29EE"); + symbolunicode.put("errbarblacksquare","\u29EF"); + symbolunicode.put("errbardiamond","\u29F0"); + symbolunicode.put("errbarblackdiamond","\u29F1"); + symbolunicode.put("errbarcircle","\u29F2"); + symbolunicode.put("errbarblackcircle","\u29F3"); + symbolunicode.put("perps","\u2AE1"); + symbolunicode.put("topcir","\u2AF1"); + symbolunicode.put("dottedsquare","\u2B1A"); + symbolunicode.put("lgblksquare","\u2B1B"); + symbolunicode.put("lgwhtsquare","\u2B1C"); + symbolunicode.put("medwhitestar","\u2B50"); + symbolunicode.put("medblackstar","\u2B51"); + symbolunicode.put("smwhitestar","\u2B52"); */ + symbolunicode.put("less","\u003C"); + symbolunicode.put("equal","\u003D"); + symbolunicode.put("greater","\u003E"); + /* symbolunicode.put("closure","\u2050"); + symbolunicode.put("leftarrow","\u2190"); + symbolunicode.put("uparrow","\u2191"); + symbolunicode.put("rightarrow","\u2192"); + symbolunicode.put("downarrow","\u2193"); + symbolunicode.put("leftrightarrow","\u2194"); + symbolunicode.put("updownarrow","\u2195"); + symbolunicode.put("nwarrow","\u2196"); + symbolunicode.put("nearrow","\u2197"); + symbolunicode.put("searrow","\u2198"); + symbolunicode.put("swarrow","\u2199"); + symbolunicode.put("nleftarrow","\u219A"); + symbolunicode.put("nrightarrow","\u219B"); + symbolunicode.put("leftwavearrow","\u219C"); + symbolunicode.put("rightwavearrow","\u219D"); + symbolunicode.put("twoheadleftarrow","\u219E"); + symbolunicode.put("twoheaduparrow","\u219F"); + symbolunicode.put("twoheadrightarrow","\u21A0"); + symbolunicode.put("twoheaddownarrow","\u21A1"); + symbolunicode.put("leftarrowtail","\u21A2"); + symbolunicode.put("rightarrowtail","\u21A3"); + symbolunicode.put("mapsfrom","\u21A4"); + symbolunicode.put("mapsup","\u21A5"); + symbolunicode.put("mapsto(","\u21A6"); + symbolunicode.put("mapsdown","\u21A7"); + symbolunicode.put("hookleftarrow","\u21A9"); + symbolunicode.put("hookrightarrow","\u21AA"); + symbolunicode.put("looparrowleft","\u21AB"); + symbolunicode.put("looparrowright","\u21AC"); + symbolunicode.put("leftrightsquigarrow","\u21AD"); + symbolunicode.put("nleftrightarrow","\u21AE"); + symbolunicode.put("downzigzagarrow","\u21AF"); + symbolunicode.put("Lsh","\u21B0"); + symbolunicode.put("Rsh","\u21B1"); + symbolunicode.put("Ldsh","\u21B2"); + symbolunicode.put("Rdsh","\u21B3"); + symbolunicode.put("curvearrowleft","\u21B6"); + symbolunicode.put("curvearrowright","\u21B7"); + symbolunicode.put("leftharpoonup","\u21BC"); + symbolunicode.put("leftharpoondown","\u21BD"); + symbolunicode.put("upharpoonright","\u21BE"); + symbolunicode.put("upharpoonleft","\u21BF"); + symbolunicode.put("rightharpoonup","\u21C0"); + symbolunicode.put("rightharpoondown","\u21C1"); + symbolunicode.put("downharpoonright","\u21C2"); + symbolunicode.put("downharpoonleft","\u21C3"); + symbolunicode.put("rightleftarrows","\u21C4"); + symbolunicode.put("updownarrows","\u21C5"); + symbolunicode.put("leftrightarrows","\u21C6"); + symbolunicode.put("leftleftarrows","\u21C7"); + symbolunicode.put("upuparrows","\u21C8"); + symbolunicode.put("rightrightarrows","\u21C9"); + symbolunicode.put("downdownarrows","\u21CA"); + symbolunicode.put("leftrightharpoons","\u21CB"); + symbolunicode.put("rightleftharpoons","\u21CC"); + symbolunicode.put("nLeftarrow","\u21CD"); + symbolunicode.put("nLeftrightarrow","\u21CE"); + symbolunicode.put("nRightarrow","\u21CF"); + symbolunicode.put("Leftarrow","\u21D0"); + symbolunicode.put("Uparrow","\u21D1"); + symbolunicode.put("Rightarrow","\u21D2"); + symbolunicode.put("Downarrow","\u21D3"); + symbolunicode.put("Leftrightarrow","\u21D4"); + symbolunicode.put("Updownarrow","\u21D5"); + symbolunicode.put("Nwarrow","\u21D6"); + symbolunicode.put("Nearrow","\u21D7"); + symbolunicode.put("Searrow","\u21D8"); + symbolunicode.put("Swarrow","\u21D9"); + symbolunicode.put("Lleftarrow","\u21DA"); + symbolunicode.put("Rrightarrow","\u21DB"); + symbolunicode.put("leftsquigarrow","\u21DC"); + symbolunicode.put("rightsquigarrow","\u21DD"); + symbolunicode.put("barleftarrow","\u21E4"); + symbolunicode.put("rightarrowbar","\u21E5"); + symbolunicode.put("circleonrightarrow","\u21F4"); + symbolunicode.put("downuparrows","\u21F5"); + symbolunicode.put("rightthreearrows","\u21F6"); + symbolunicode.put("nvleftarrow","\u21F7"); + symbolunicode.put("nvrightarrow","\u21F8"); + symbolunicode.put("nvleftrightarrow","\u21F9"); + symbolunicode.put("nVleftarrow","\u21FA"); + symbolunicode.put("nVrightarrow","\u21FB"); + symbolunicode.put("nVleftrightarrow","\u21FC"); + symbolunicode.put("leftarrowtriangle","\u21FD"); + symbolunicode.put("rightarrowtriangle","\u21FE"); + symbolunicode.put("leftrightarrowtriangle","\u21FF"); + symbolunicode.put("in","\u2208"); + symbolunicode.put("notin","\u2209"); + symbolunicode.put("smallin","\u220A"); + symbolunicode.put("ni","\u220B"); + symbolunicode.put("nni","\u220C"); + symbolunicode.put("smallni","\u220D"); + symbolunicode.put("propto","\u221D"); + symbolunicode.put("mid","\u2223"); + symbolunicode.put("nmid","\u2224"); + symbolunicode.put("parallel","\u2225"); + symbolunicode.put("nparallel","\u2226"); + symbolunicode.put("mathratio","\u2236"); + symbolunicode.put("Colon","\u2237"); + symbolunicode.put("dashcolon","\u2239"); + symbolunicode.put("dotsminusdots","\u223A"); + symbolunicode.put("kernelcontraction","\u223B"); */ + symbolunicode.put("sim","\u223C"); +// symbolunicode.put("backsim","\u223D"); + symbolunicode.put("nsim","\u2241"); + symbolunicode.put("eqsim","\u2242"); + symbolunicode.put("simeq","\u2243"); + symbolunicode.put("nsime","\u2244"); + // symbolunicode.put("cong","\u2245"); + // symbolunicode.put("simneqq","\u2246"); + // symbolunicode.put("ncong","\u2247"); + symbolunicode.put("approx","\u2248"); + symbolunicode.put("napprox","\u2249"); + symbolunicode.put("approxeq","\u224A"); + /* symbolunicode.put("approxident","\u224B"); + symbolunicode.put("backcong","\u224C"); + symbolunicode.put("asymp","\u224D"); + symbolunicode.put("Bumpeq","\u224E"); + symbolunicode.put("bumpeq","\u224F"); + symbolunicode.put("doteq","\u2250"); + symbolunicode.put("Doteq","\u2251"); + symbolunicode.put("fallingdotseq","\u2252"); + symbolunicode.put("risingdotseq","\u2253"); + symbolunicode.put("coloneq","\u2254"); + symbolunicode.put("eqcolon","\u2255"); + symbolunicode.put("eqcirc","\u2256"); + symbolunicode.put("circeq","\u2257"); + symbolunicode.put("arceq","\u2258"); + symbolunicode.put("wedgeq","\u2259"); + symbolunicode.put("veeeq","\u225A"); + symbolunicode.put("stareq","\u225B"); + symbolunicode.put("triangleq","\u225C"); + symbolunicode.put("eqdef","\u225D"); + symbolunicode.put("measeq","\u225E"); + symbolunicode.put("questeq","\u225F"); */ + symbolunicode.put("ne","\u2260"); + symbolunicode.put("equiv","\u2261"); + symbolunicode.put("nequiv","\u2262"); + symbolunicode.put("Equiv","\u2263"); + symbolunicode.put("leq","\u2264"); + symbolunicode.put("geq","\u2265"); + symbolunicode.put("leqq","\u2266"); + symbolunicode.put("geqq","\u2267"); + symbolunicode.put("lneqq","\u2268"); + symbolunicode.put("gneqq","\u2269"); + symbolunicode.put("ll","\u226A"); + symbolunicode.put("gg","\u226B"); + /* symbolunicode.put("between","\u226C"); + symbolunicode.put("nasymp","\u226D"); + symbolunicode.put("nless","\u226E"); + symbolunicode.put("ngtr","\u226F"); + symbolunicode.put("nleq","\u2270"); + symbolunicode.put("ngeq","\u2271"); + symbolunicode.put("lesssim","\u2272"); + symbolunicode.put("gtrsim","\u2273"); + symbolunicode.put("nlesssim","\u2274"); + symbolunicode.put("ngtrsim","\u2275"); + symbolunicode.put("lessgtr","\u2276"); + symbolunicode.put("gtrless","\u2277"); + symbolunicode.put("nlessgtr","\u2278"); + symbolunicode.put("ngtrless","\u2279"); + symbolunicode.put("prec","\u227A"); + symbolunicode.put("succ","\u227B"); + symbolunicode.put("preccurlyeq","\u227C"); + symbolunicode.put("succcurlyeq","\u227D"); + symbolunicode.put("precsim","\u227E"); + symbolunicode.put("succsim","\u227F"); + symbolunicode.put("nprec","\u2280"); + symbolunicode.put("nsucc","\u2281"); + symbolunicode.put("subset","\u2282"); + symbolunicode.put("supset","\u2283"); + symbolunicode.put("nsubset","\u2284"); + symbolunicode.put("nsupset","\u2285"); + symbolunicode.put("subseteq","\u2286"); + symbolunicode.put("supseteq","\u2287"); + symbolunicode.put("nsubseteq","\u2288"); + symbolunicode.put("nsupseteq","\u2289"); + symbolunicode.put("subsetneq","\u228A"); + symbolunicode.put("supsetneq","\u228B"); + symbolunicode.put("sqsubset","\u228F"); + symbolunicode.put("sqsupset","\u2290"); + symbolunicode.put("sqsubseteq","\u2291"); + symbolunicode.put("sqsupseteq","\u2292"); + symbolunicode.put("vdash","\u22A2"); + symbolunicode.put("dashv","\u22A3"); + symbolunicode.put("assert","\u22A6"); + symbolunicode.put("models","\u22A7"); + symbolunicode.put("vDash","\u22A8"); + symbolunicode.put("Vdash","\u22A9"); + symbolunicode.put("Vvdash","\u22AA"); + symbolunicode.put("VDash","\u22AB"); + symbolunicode.put("nvdash","\u22AC"); + symbolunicode.put("nvDash","\u22AD"); + symbolunicode.put("nVdash","\u22AE"); + symbolunicode.put("nVDash","\u22AF"); + symbolunicode.put("prurel","\u22B0"); + symbolunicode.put("scurel","\u22B1"); + symbolunicode.put("vartriangleleft","\u22B2"); + symbolunicode.put("vartriangleright","\u22B3"); + symbolunicode.put("trianglelefteq","\u22B4"); + symbolunicode.put("trianglerighteq","\u22B5"); + symbolunicode.put("origof","\u22B6"); + symbolunicode.put("imageof","\u22B7"); + symbolunicode.put("multimap","\u22B8"); + symbolunicode.put("bowtie","\u22C8"); + symbolunicode.put("backsimeq","\u22CD"); + symbolunicode.put("Subset","\u22D0"); + symbolunicode.put("Supset","\u22D1"); + symbolunicode.put("pitchfork","\u22D4"); + symbolunicode.put("equalparallel","\u22D5"); + symbolunicode.put("lessdot","\u22D6"); + symbolunicode.put("gtrdot","\u22D7"); + symbolunicode.put("lll","\u22D8"); + symbolunicode.put("ggg","\u22D9"); + symbolunicode.put("lesseqgtr","\u22DA"); + symbolunicode.put("gtreqless","\u22DB"); + symbolunicode.put("eqless","\u22DC"); + symbolunicode.put("eqgtr","\u22DD"); + symbolunicode.put("curlyeqprec","\u22DE"); + symbolunicode.put("curlyeqsucc","\u22DF"); + symbolunicode.put("npreccurlyeq","\u22E0"); + symbolunicode.put("nsucccurlyeq","\u22E1"); + symbolunicode.put("nsqsubseteq","\u22E2"); + symbolunicode.put("nsqsupseteq","\u22E3"); + symbolunicode.put("sqsubsetneq","\u22E4"); + symbolunicode.put("sqsupsetneq","\u22E5"); + symbolunicode.put("lnsim","\u22E6"); + symbolunicode.put("gnsim","\u22E7"); + symbolunicode.put("precnsim","\u22E8"); + symbolunicode.put("succnsim","\u22E9"); + symbolunicode.put("nvartriangleleft","\u22EA"); + symbolunicode.put("nvartriangleright","\u22EB"); + symbolunicode.put("ntrianglelefteq","\u22EC"); + symbolunicode.put("ntrianglerighteq","\u22ED"); + symbolunicode.put("vdots","\u22EE"); + symbolunicode.put("adots","\u22F0"); + symbolunicode.put("ddots","\u22F1"); + symbolunicode.put("disin","\u22F2"); + symbolunicode.put("varisins","\u22F3"); + symbolunicode.put("isins","\u22F4"); + symbolunicode.put("isindot","\u22F5"); + symbolunicode.put("varisinobar","\u22F6"); + symbolunicode.put("isinobar","\u22F7"); + symbolunicode.put("isinvb","\u22F8"); + symbolunicode.put("isinE","\u22F9"); + symbolunicode.put("nisd","\u22FA"); + symbolunicode.put("varnis","\u22FB"); + symbolunicode.put("nis","\u22FC"); + symbolunicode.put("varniobar","\u22FD"); + symbolunicode.put("niobar","\u22FE"); + symbolunicode.put("bagmember","\u22FF"); + symbolunicode.put("frown","\u2322"); + symbolunicode.put("smile","\u2323"); + symbolunicode.put("perp","\u27C2"); + symbolunicode.put("bsolhsub","\u27C8"); + symbolunicode.put("suphsol","\u27C9"); + symbolunicode.put("upin","\u27D2"); + symbolunicode.put("pullback","\u27D3"); + symbolunicode.put("pushout","\u27D4"); + symbolunicode.put("DashVDash","\u27DA"); + symbolunicode.put("dashVdash","\u27DB"); + symbolunicode.put("multimapinv","\u27DC"); + symbolunicode.put("vlongdash","\u27DD"); + symbolunicode.put("longdashv","\u27DE"); + symbolunicode.put("cirbot","\u27DF"); + symbolunicode.put("UUparrow","\u27F0"); + symbolunicode.put("DDownarrow","\u27F1"); + symbolunicode.put("acwgapcirclearrow","\u27F2"); + symbolunicode.put("cwgapcirclearrow","\u27F3"); + symbolunicode.put("rightarrowonoplus","\u27F4"); + symbolunicode.put("longleftarrow","\u27F5"); + symbolunicode.put("longrightarrow","\u27F6"); + symbolunicode.put("longleftrightarrow","\u27F7"); + symbolunicode.put("Longleftarrow","\u27F8"); + symbolunicode.put("Longrightarrow","\u27F9"); + symbolunicode.put("Longleftrightarrow","\u27FA"); + symbolunicode.put("longmapsfrom","\u27FB"); + symbolunicode.put("longmapsto","\u27FC"); + symbolunicode.put("Longmapsfrom","\u27FD"); + symbolunicode.put("Longmapsto","\u27FE"); + symbolunicode.put("longrightsquigarrow","\u27FF"); + symbolunicode.put("nvtwoheadrightarrow","\u2900"); + symbolunicode.put("nVtwoheadrightarrow","\u2901"); + symbolunicode.put("nvLeftarrow","\u2902"); + symbolunicode.put("nvRightarrow","\u2903"); + symbolunicode.put("nvLeftrightarrow","\u2904"); + symbolunicode.put("twoheadmapsto","\u2905"); + symbolunicode.put("Mapsfrom","\u2906"); + symbolunicode.put("Mapsto","\u2907"); + symbolunicode.put("downarrowbarred","\u2908"); + symbolunicode.put("uparrowbarred","\u2909"); + symbolunicode.put("Uuparrow","\u290A"); + symbolunicode.put("Ddownarrow","\u290B"); + symbolunicode.put("leftbkarrow","\u290C"); + symbolunicode.put("rightbkarrow","\u290D"); + symbolunicode.put("leftdbkarrow","\u290E"); + symbolunicode.put("dbkarow","\u290F"); + symbolunicode.put("drbkarow","\u2910"); + symbolunicode.put("rightdotarrow","\u2911"); + symbolunicode.put("baruparrow","\u2912"); + symbolunicode.put("downarrowbar","\u2913"); + symbolunicode.put("nvrightarrowtail","\u2914"); + symbolunicode.put("nVrightarrowtail","\u2915"); + symbolunicode.put("twoheadrightarrowtail","\u2916"); + symbolunicode.put("nvtwoheadrightarrowtail","\u2917"); + symbolunicode.put("nVtwoheadrightarrowtail","\u2918"); + symbolunicode.put("lefttail","\u2919"); + symbolunicode.put("righttail","\u291A"); + symbolunicode.put("leftdbltail","\u291B"); + symbolunicode.put("rightdbltail","\u291C"); + symbolunicode.put("diamondleftarrow","\u291D"); + symbolunicode.put("rightarrowdiamond","\u291E"); + symbolunicode.put("diamondleftarrowbar","\u291F"); + symbolunicode.put("barrightarrowdiamond","\u2920"); + symbolunicode.put("nwsearrow","\u2921"); + symbolunicode.put("neswarrow","\u2922"); + symbolunicode.put("hknwarrow","\u2923"); + symbolunicode.put("hknearrow","\u2924"); + symbolunicode.put("hksearow","\u2925"); + symbolunicode.put("hkswarow","\u2926"); + symbolunicode.put("tona","\u2927"); + symbolunicode.put("toea","\u2928"); + symbolunicode.put("tosa","\u2929"); + symbolunicode.put("towa","\u292A"); + symbolunicode.put("rightcurvedarrow","\u2933"); + symbolunicode.put("leftdowncurvedarrow","\u2936"); + symbolunicode.put("rightdowncurvedarrow","\u2937"); + symbolunicode.put("cwrightarcarrow","\u2938"); + symbolunicode.put("acwleftarcarrow","\u2939"); + symbolunicode.put("acwoverarcarrow","\u293A"); + symbolunicode.put("acwunderarcarrow","\u293B"); + symbolunicode.put("curvearrowrightminus","\u293C"); + symbolunicode.put("curvearrowleftplus","\u293D"); + symbolunicode.put("cwundercurvearrow","\u293E"); + symbolunicode.put("ccwundercurvearrow","\u293F"); + symbolunicode.put("acwcirclearrow","\u2940"); + symbolunicode.put("cwcirclearrow","\u2941"); + symbolunicode.put("rightarrowshortleftarrow","\u2942"); + symbolunicode.put("leftarrowshortrightarrow","\u2943"); + symbolunicode.put("shortrightarrowleftarrow","\u2944"); + symbolunicode.put("rightarrowplus","\u2945"); + symbolunicode.put("leftarrowplus","\u2946"); + symbolunicode.put("rightarrowx","\u2947"); + symbolunicode.put("leftrightarrowcircle","\u2948"); + symbolunicode.put("twoheaduparrowcircle","\u2949"); + symbolunicode.put("leftrightharpoonupdown","\u294A"); + symbolunicode.put("leftrightharpoondownup","\u294B"); + symbolunicode.put("updownharpoonrightleft","\u294C"); + symbolunicode.put("updownharpoonleftright","\u294D"); + symbolunicode.put("leftrightharpoonupup","\u294E"); + symbolunicode.put("updownharpoonrightright","\u294F"); + symbolunicode.put("leftrightharpoondowndown","\u2950"); + symbolunicode.put("updownharpoonleftleft","\u2951"); + symbolunicode.put("barleftharpoonup","\u2952"); + symbolunicode.put("rightharpoonupbar","\u2953"); + symbolunicode.put("barupharpoonright","\u2954"); + symbolunicode.put("downharpoonrightbar","\u2955"); + symbolunicode.put("barleftharpoondown","\u2956"); + symbolunicode.put("rightharpoondownbar","\u2957"); + symbolunicode.put("barupharpoonleft","\u2958"); + symbolunicode.put("downharpoonleftbar","\u2959"); + symbolunicode.put("leftharpoonupbar","\u295A"); + symbolunicode.put("barrightharpoonup","\u295B"); + symbolunicode.put("upharpoonrightbar","\u295C"); + symbolunicode.put("bardownharpoonright","\u295D"); + symbolunicode.put("leftharpoondownbar","\u295E"); + symbolunicode.put("barrightharpoondown","\u295F"); + symbolunicode.put("upharpoonleftbar","\u2960"); + symbolunicode.put("bardownharpoonleft","\u2961"); + symbolunicode.put("leftharpoonsupdown","\u2962"); + symbolunicode.put("upharpoonsleftright","\u2963"); + symbolunicode.put("rightharpoonsupdown","\u2964"); + symbolunicode.put("downharpoonsleftright","\u2965"); + symbolunicode.put("leftrightharpoonsup","\u2966"); + symbolunicode.put("leftrightharpoonsdown","\u2967"); + symbolunicode.put("rightleftharpoonsup","\u2968"); + symbolunicode.put("rightleftharpoonsdown","\u2969"); + symbolunicode.put("leftharpoonupdash","\u296A"); + symbolunicode.put("dashleftharpoondown","\u296B"); + symbolunicode.put("rightharpoonupdash","\u296C"); + symbolunicode.put("dashrightharpoondown","\u296D"); + symbolunicode.put("updownharpoonsleftright","\u296E"); + symbolunicode.put("downupharpoonsleftright","\u296F"); + symbolunicode.put("rightimply","\u2970"); + symbolunicode.put("equalrightarrow","\u2971"); + symbolunicode.put("similarrightarrow","\u2972"); + symbolunicode.put("leftarrowsimilar","\u2973"); + symbolunicode.put("rightarrowsimilar","\u2974"); + symbolunicode.put("rightarrowapprox","\u2975"); + symbolunicode.put("ltlarr","\u2976"); + symbolunicode.put("leftarrowless","\u2977"); + symbolunicode.put("gtrarr","\u2978"); + symbolunicode.put("subrarr","\u2979"); + symbolunicode.put("leftarrowsubset","\u297A"); + symbolunicode.put("suplarr","\u297B"); + symbolunicode.put("leftfishtail","\u297C"); + symbolunicode.put("rightfishtail","\u297D"); + symbolunicode.put("upfishtail","\u297E"); + symbolunicode.put("downfishtail","\u297F"); + symbolunicode.put("rtriltri","\u29CE"); + symbolunicode.put("ltrivb","\u29CF"); + symbolunicode.put("vbrtri","\u29D0"); + symbolunicode.put("lfbowtie","\u29D1"); + symbolunicode.put("rfbowtie","\u29D2"); + symbolunicode.put("fbowtie","\u29D3"); + symbolunicode.put("lftimes","\u29D4"); + symbolunicode.put("rftimes","\u29D5"); + symbolunicode.put("dualmap","\u29DF"); + symbolunicode.put("lrtriangleeq","\u29E1"); + symbolunicode.put("eparsl","\u29E3"); + symbolunicode.put("smeparsl","\u29E4"); + symbolunicode.put("eqvparsl","\u29E5"); + symbolunicode.put("gleichstark","\u29E6"); + symbolunicode.put("ruledelayed","\u29F4"); + symbolunicode.put("veeonwedge","\u2A59"); + symbolunicode.put("eqdot","\u2A66"); + symbolunicode.put("dotequiv","\u2A67"); + symbolunicode.put("equivVert","\u2A68"); + symbolunicode.put("equivVvert","\u2A69"); + symbolunicode.put("dotsim","\u2A6A"); + symbolunicode.put("simrdots","\u2A6B"); + symbolunicode.put("simminussim","\u2A6C"); + symbolunicode.put("congdot","\u2A6D"); + symbolunicode.put("asteq","\u2A6E"); + symbolunicode.put("hatapprox","\u2A6F"); + symbolunicode.put("approxeqq","\u2A70"); + symbolunicode.put("eqqsim","\u2A73"); + symbolunicode.put("Coloneq","\u2A74"); + symbolunicode.put("eqeq","\u2A75"); + symbolunicode.put("eqeqeq","\u2A76"); + symbolunicode.put("ddotseq","\u2A77"); + symbolunicode.put("equivDD","\u2A78"); + symbolunicode.put("ltcir","\u2A79"); + symbolunicode.put("gtcir","\u2A7A"); + symbolunicode.put("ltquest","\u2A7B"); + symbolunicode.put("gtquest","\u2A7C"); + symbolunicode.put("leqslant","\u2A7D"); + symbolunicode.put("geqslant","\u2A7E"); + symbolunicode.put("lesdot","\u2A7F"); + symbolunicode.put("gesdot","\u2A80"); + symbolunicode.put("lesdoto","\u2A81"); + symbolunicode.put("gesdoto","\u2A82"); + symbolunicode.put("lesdotor","\u2A83"); + symbolunicode.put("gesdotol","\u2A84"); + symbolunicode.put("lessapprox","\u2A85"); + symbolunicode.put("gtrapprox","\u2A86"); + symbolunicode.put("lneq","\u2A87"); + symbolunicode.put("gneq","\u2A88"); + symbolunicode.put("lnapprox","\u2A89"); + symbolunicode.put("gnapprox","\u2A8A"); + symbolunicode.put("lesseqqgtr","\u2A8B"); + symbolunicode.put("gtreqqless","\u2A8C"); + symbolunicode.put("lsime","\u2A8D"); + symbolunicode.put("gsime","\u2A8E"); + symbolunicode.put("lsimg","\u2A8F"); + symbolunicode.put("gsiml","\u2A90"); + symbolunicode.put("lgE","\u2A91"); + symbolunicode.put("glE","\u2A92"); + symbolunicode.put("lesges","\u2A93"); + symbolunicode.put("gesles","\u2A94"); + symbolunicode.put("eqslantless","\u2A95"); + symbolunicode.put("eqslantgtr","\u2A96"); + symbolunicode.put("elsdot","\u2A97"); + symbolunicode.put("egsdot","\u2A98"); + symbolunicode.put("eqqless","\u2A99"); + symbolunicode.put("eqqgtr","\u2A9A"); + symbolunicode.put("eqqslantless","\u2A9B"); + symbolunicode.put("eqqslantgtr","\u2A9C"); + symbolunicode.put("simless","\u2A9D"); + symbolunicode.put("simgtr","\u2A9E"); + symbolunicode.put("simlE","\u2A9F"); + symbolunicode.put("simgE","\u2AA0"); + symbolunicode.put("Lt","\u2AA1"); + symbolunicode.put("Gt","\u2AA2"); + symbolunicode.put("partialmeetcontraction","\u2AA3"); + symbolunicode.put("glj","\u2AA4"); + symbolunicode.put("gla","\u2AA5"); + symbolunicode.put("ltcc","\u2AA6"); + symbolunicode.put("gtcc","\u2AA7"); + symbolunicode.put("lescc","\u2AA8"); + symbolunicode.put("gescc","\u2AA9"); + symbolunicode.put("smt","\u2AAA"); + symbolunicode.put("lat","\u2AAB"); + symbolunicode.put("smte","\u2AAC"); + symbolunicode.put("late","\u2AAD"); + symbolunicode.put("bumpeqq","\u2AAE"); + symbolunicode.put("preceq","\u2AAF"); + symbolunicode.put("succeq","\u2AB0"); + symbolunicode.put("precneq","\u2AB1"); + symbolunicode.put("succneq","\u2AB2"); + symbolunicode.put("preceqq","\u2AB3"); + symbolunicode.put("succeqq","\u2AB4"); + symbolunicode.put("precneqq","\u2AB5"); + symbolunicode.put("succneqq","\u2AB6"); + symbolunicode.put("precapprox","\u2AB7"); + symbolunicode.put("succapprox","\u2AB8"); + symbolunicode.put("precnapprox","\u2AB9"); + symbolunicode.put("succnapprox","\u2ABA"); + symbolunicode.put("Prec","\u2ABB"); + symbolunicode.put("Succ","\u2ABC"); + symbolunicode.put("subsetdot","\u2ABD"); + symbolunicode.put("supsetdot","\u2ABE"); + symbolunicode.put("subsetplus","\u2ABF"); + symbolunicode.put("supsetplus","\u2AC0"); + symbolunicode.put("submult","\u2AC1"); + symbolunicode.put("supmult","\u2AC2"); + symbolunicode.put("subedot","\u2AC3"); + symbolunicode.put("supedot","\u2AC4"); + symbolunicode.put("subseteqq","\u2AC5"); + symbolunicode.put("supseteqq","\u2AC6"); + symbolunicode.put("subsim","\u2AC7"); + symbolunicode.put("supsim","\u2AC8"); + symbolunicode.put("subsetapprox","\u2AC9"); + symbolunicode.put("supsetapprox","\u2ACA"); + symbolunicode.put("subsetneqq","\u2ACB"); + symbolunicode.put("supsetneqq","\u2ACC"); + symbolunicode.put("lsqhook","\u2ACD"); + symbolunicode.put("rsqhook","\u2ACE"); + symbolunicode.put("csub","\u2ACF"); + symbolunicode.put("csup","\u2AD0"); + symbolunicode.put("csube","\u2AD1"); + symbolunicode.put("csupe","\u2AD2"); + symbolunicode.put("subsup","\u2AD3"); + symbolunicode.put("supsub","\u2AD4"); + symbolunicode.put("subsub","\u2AD5"); + symbolunicode.put("supsup","\u2AD6"); + symbolunicode.put("suphsub","\u2AD7"); + symbolunicode.put("supdsub","\u2AD8"); + symbolunicode.put("forkv","\u2AD9"); + symbolunicode.put("topfork","\u2ADA"); + symbolunicode.put("mlcp","\u2ADB"); + symbolunicode.put("forks","\u2ADC"); + symbolunicode.put("forksnot","\u2ADD"); + symbolunicode.put("shortlefttack","\u2ADE"); + symbolunicode.put("shortdowntack","\u2ADF"); + symbolunicode.put("shortuptack","\u2AE0"); + symbolunicode.put("vDdash","\u2AE2"); + symbolunicode.put("dashV","\u2AE3"); + symbolunicode.put("Dashv","\u2AE4"); + symbolunicode.put("DashV","\u2AE5"); + symbolunicode.put("varVdash","\u2AE6"); + symbolunicode.put("Barv","\u2AE7"); + symbolunicode.put("vBar","\u2AE8"); + symbolunicode.put("vBarv","\u2AE9"); + symbolunicode.put("barV","\u2AEA"); + symbolunicode.put("Vbar","\u2AEB"); + symbolunicode.put("Not","\u2AEC"); + symbolunicode.put("bNot","\u2AED"); + symbolunicode.put("revnmid","\u2AEE"); + symbolunicode.put("cirmid","\u2AEF"); + symbolunicode.put("midcir","\u2AF0"); + symbolunicode.put("nhpar","\u2AF2"); + symbolunicode.put("parsim","\u2AF3"); + symbolunicode.put("lllnest","\u2AF7"); + symbolunicode.put("gggnest","\u2AF8"); + symbolunicode.put("leqqslant","\u2AF9"); + symbolunicode.put("geqqslant","\u2AFA"); + symbolunicode.put("circleonleftarrow","\u2B30"); + symbolunicode.put("leftthreearrows","\u2B31"); + symbolunicode.put("leftarrowonoplus","\u2B32"); + symbolunicode.put("longleftsquigarrow","\u2B33"); + symbolunicode.put("nvtwoheadleftarrow","\u2B34"); + symbolunicode.put("nVtwoheadleftarrow","\u2B35"); + symbolunicode.put("twoheadmapsfrom","\u2B36"); + symbolunicode.put("twoheadleftdbkarrow","\u2B37"); + symbolunicode.put("leftdotarrow","\u2B38"); + symbolunicode.put("nvleftarrowtail","\u2B39"); + symbolunicode.put("nVleftarrowtail","\u2B3A"); + symbolunicode.put("twoheadleftarrowtail","\u2B3B"); + symbolunicode.put("nvtwoheadleftarrowtail","\u2B3C"); + symbolunicode.put("nVtwoheadleftarrowtail","\u2B3D"); + symbolunicode.put("leftarrowx","\u2B3E"); + symbolunicode.put("leftcurvedarrow","\u2B3F"); + symbolunicode.put("equalleftarrow","\u2B40"); + symbolunicode.put("bsimilarleftarrow","\u2B41"); + symbolunicode.put("leftarrowbackapprox","\u2B42"); + symbolunicode.put("rightarrowgtr","\u2B43"); + symbolunicode.put("rightarrowsupset","\u2B44"); + symbolunicode.put("LLeftarrow","\u2B45"); + symbolunicode.put("RRightarrow","\u2B46"); + symbolunicode.put("bsimilarrightarrow","\u2B47"); + symbolunicode.put("rightarrowbackapprox","\u2B48"); + symbolunicode.put("similarleftarrow","\u2B49"); + symbolunicode.put("leftarrowapprox","\u2B4A"); + symbolunicode.put("leftarrowbsimilar","\u2B4B"); + symbolunicode.put("rightarrowbsimilar","\u2B4C"); */ + symbolunicode.put("Alpha","\u0391"); + symbolunicode.put("Beta","\u0392"); + symbolunicode.put("Gamma","\u0393"); + symbolunicode.put("Delta","\u0394"); + symbolunicode.put("Epsilon","\u0395"); + symbolunicode.put("Zeta","\u0396"); + symbolunicode.put("Eta","\u0397"); + symbolunicode.put("Theta","\u0398"); + symbolunicode.put("Iota","\u0399"); + symbolunicode.put("Kappa","\u039A"); + symbolunicode.put("Lambda","\u039B"); + symbolunicode.put("Mu","\u039C"); + symbolunicode.put("Nu","\u039D"); + symbolunicode.put("Xi","\u039E"); + symbolunicode.put("Omicron","\u039F"); + symbolunicode.put("Pi","\u03A0"); + symbolunicode.put("Rho","\u03A1"); + symbolunicode.put("Sigma","\u03A3"); + symbolunicode.put("Tau","\u03A4"); + symbolunicode.put("Upsilon","\u03A5"); + symbolunicode.put("Phi","\u03A6"); + symbolunicode.put("Chi","\u03A7"); + symbolunicode.put("Psi","\u03A8"); + symbolunicode.put("Omega","\u03A9"); + symbolunicode.put("alpha","\u03B1"); + symbolunicode.put("beta","\u03B2"); + symbolunicode.put("gamma","\u03B3"); + symbolunicode.put("delta","\u03B4"); + symbolunicode.put("epsilon","\u03B5"); + symbolunicode.put("zeta","\u03B6"); + symbolunicode.put("eta","\u03B7"); + symbolunicode.put("theta","\u03B8"); + symbolunicode.put("iota","\u03B9"); + symbolunicode.put("kappa","\u03BA"); + symbolunicode.put("lambda","\u03BB"); + symbolunicode.put("mu","\u03BC"); + symbolunicode.put("nu","\u03BD"); + symbolunicode.put("xi","\u03BE"); + symbolunicode.put("omicron","\u03BF"); + symbolunicode.put("pi","\u03C0"); + symbolunicode.put("rho","\u03C1"); + symbolunicode.put("varsigma","\u03C2"); + symbolunicode.put("sigma","\u03C3"); + symbolunicode.put("tau","\u03C4"); + symbolunicode.put("upsilon","\u03C5"); + symbolunicode.put("varphi","\u03C6"); + symbolunicode.put("chi","\u03C7"); + symbolunicode.put("psi","\u03C8"); + symbolunicode.put("omega","\u03C9"); + symbolunicode.put("varbeta","\u03D0"); + symbolunicode.put("vartheta","\u03D1"); + symbolunicode.put("phi","\u03D5"); + symbolunicode.put("varpi","\u03D6"); + symbolunicode.put("Digamma","\u03DC"); + symbolunicode.put("digamma","\u03DD"); + symbolunicode.put("varkappa","\u03F0"); + symbolunicode.put("varrho","\u03F1"); + symbolunicode.put("varTheta","\u03F4"); + symbolunicode.put("varepsilon","\u03F5"); + symbolunicode.put("matheth","\u00F0"); + symbolunicode.put("BbbC","\u2102"); + symbolunicode.put("mscrg","\u210A"); + symbolunicode.put("mscrH","\u210B"); + symbolunicode.put("mfrakH","\u210C"); + symbolunicode.put("BbbH","\u210D"); + symbolunicode.put("hslash","\u210F"); + symbolunicode.put("mscrI","\u2110"); + symbolunicode.put("Im","\u2111"); + symbolunicode.put("mscrL","\u2112"); + symbolunicode.put("ell","\u2113"); + symbolunicode.put("BbbN","\u2115"); + symbolunicode.put("wp","\u2118"); + symbolunicode.put("BbbP","\u2119"); + symbolunicode.put("BbbQ","\u211A"); + symbolunicode.put("mscrR","\u211B"); + symbolunicode.put("Re","\u211C"); + symbolunicode.put("BbbR","\u211D"); + symbolunicode.put("BbbZ","\u2124"); + symbolunicode.put("mfrakZ","\u2128"); + symbolunicode.put("turnediota","\u2129"); + symbolunicode.put("Angstrom","\u212B"); + symbolunicode.put("mscrB","\u212C"); + symbolunicode.put("mfrakC","\u212D"); + symbolunicode.put("mscre","\u212F"); + symbolunicode.put("mscrE","\u2130"); + symbolunicode.put("mscrF","\u2131"); + symbolunicode.put("mscrM","\u2133"); + symbolunicode.put("mscro","\u2134"); + symbolunicode.put("aleph","\u2135"); + symbolunicode.put("beth","\u2136"); + symbolunicode.put("gimel","\u2137"); + symbolunicode.put("daleth","\u2138"); + symbolunicode.put("Bbbgamma","\u213D"); + symbolunicode.put("BbbGamma","\u213E"); + symbolunicode.put("BbbPi","\u213F"); + symbolunicode.put("partial","\u2202"); + symbolunicode.put("nabla","\u2207"); + symbolunicode.put("log","log"); + symbolunicode.put("ln","ln"); + symbolunicode.put("sin","sin"); + symbolunicode.put("cos","cos"); + symbolunicode.put("tan","tan"); + symbolunicode.put("sec","sec"); + symbolunicode.put("csc","csc"); + symbolunicode.put("cot","cot"); + symbolunicode.put("sinh","sinh"); + symbolunicode.put("cosh","cosh"); + symbolunicode.put("tanh","tanh"); + symbolunicode.put("coth","coth"); + symbolunicode.put("sech","sech"); + symbolunicode.put("csch","csch"); + symbolunicode.put("lim","lim"); + symbolunicode.put("sqrt","\u221A"); + symbolunicode.put("cuberoot","\u221B"); + symbolunicode.put("fourthroot","\u221C"); + + +}} + + + + + + + |