text:
# generated
# length(dict) = 2479
const latex_name_table = Dict{String, String}(
    "¡" => "\\exclamdown",
    "£" => "\\sterling",
    "¥" => "\\yen",
    "¦" => "\\brokenbar",
    "§" => "\\S",
    "©" => "\\copyright",
    "ª" => "\\ordfeminine",
    "¬" => "\\neg",
    "®" => "\\circledR",
    "¯" => "\\highminus",
    "°" => "\\degree",
    "±" => "\\pm",
    "²" => "\\^2",
    "³" => "\\^3",
    "¶" => "\\P",
    "·" => "\\cdotp",
    "¹" => "\\^1",
    "º" => "\\ordmasculine",
    "¼" => "\\1/4",
    "½" => "\\1/2",
    "¾" => "\\3/4",
    "¿" => "\\questiondown",
    "Å" => "\\AA",
    "Æ" => "\\AE",
    "Ð" => "\\DH",
    "×" => "\\times",
    "Ø" => "\\O",
    "Þ" => "\\TH",
    "ß" => "\\ss",
    "å" => "\\aa",
    "æ" => "\\ae",
    "ð" => "\\dh",
    "÷" => "\\div",
    "ø" => "\\o",
    "þ" => "\\th",
    "Đ" => "\\DJ",
    "đ" => "\\dj",
    "ħ" => "\\hbar",
    "ı" => "\\imath",
    "Ł" => "\\L",
    "ł" => "\\l",
    "Ŋ" => "\\NG",
    "ŋ" => "\\ng",
    "Œ" => "\\OE",
    "œ" => "\\oe",
    "ƕ" => "\\hvlig",
    "ƞ" => "\\nrleg",
    "Ƶ" => "\\Zbar",
    "ǂ" => "\\doublepipe",
    "ȷ" => "\\jmath",
    "ɐ" => "\\trna",
    "ɒ" => "\\trnsa",
    "ɔ" => "\\openo",
    "ɖ" => "\\rtld",
    "ə" => "\\schwa",
    "ɣ" => "\\pgamma",
    "ɤ" => "\\pbgam",
    "ɥ" => "\\trnh",
    "ɬ" => "\\btdl",
    "ɭ" => "\\rtll",
    "ɯ" => "\\trnm",
    "ɰ" => "\\trnmlr",
    "ɱ" => "\\ltlmr",
    "ɲ" => "\\ltln",
    "ɳ" => "\\rtln",
    "ɷ" => "\\clomeg",
    "ɸ" => "\\ltphi",
    "ɹ" => "\\trnr",
    "ɺ" => "\\trnrl",
    "ɻ" => "\\rttrnr",
    "ɼ" => "\\rl",
    "ɽ" => "\\rtlr",
    "ɾ" => "\\fhr",
    "ʂ" => "\\rtls",
    "ʃ" => "\\esh",
    "ʇ" => "\\trnt",
    "ʈ" => "\\rtlt",
    "ʊ" => "\\pupsil",
    "ʋ" => "\\pscrv",
    "ʌ" => "\\invv",
    "ʍ" => "\\invw",
    "ʎ" => "\\trny",
    "ʐ" => "\\rtlz",
    "ʒ" => "\\yogh",
    "ʔ" => "\\glst",
    "ʕ" => "\\reglst",
    "ʖ" => "\\inglst",
    "ʞ" => "\\turnk",
    "ʤ" => "\\dyogh",
    "ʧ" => "\\tesh",
    "ʰ" => "\\^h",
    "ʲ" => "\\^j",
    "ʳ" => "\\^r",
    "ʷ" => "\\^w",
    "ʸ" => "\\^y",
    "ʼ" => "\\rasp",
    "ˈ" => "\\verts",
    "ˌ" => "\\verti",
    "ː" => "\\lmrk",
    "ˑ" => "\\hlmrk",
    "˒" => "\\sbrhr",
    "˓" => "\\sblhr",
    "˔" => "\\rais",
    "˕" => "\\low",
    "˘" => "\\u",
    "˜" => "\\tildelow",
    "ˡ" => "\\^l",
    "ˢ" => "\\^s",
    "ˣ" => "\\^x",
    "̀" => "\\grave",
    "́" => "\\acute",
    "̂" => "\\hat",
    "̃" => "\\tilde",
    "̄" => "\\bar",
    "̅" => "\\overbar",
    "̆" => "\\breve",
    "̇" => "\\dot",
    "̈" => "\\ddot",
    "̉" => "\\ovhook",
    "̊" => "\\ocirc",
    "̋" => "\\H",
    "̌" => "\\check",
    "̐" => "\\candra",
    "̒" => "\\oturnedcomma",
    "̕" => "\\ocommatopright",
    "̚" => "\\droang",
    "̡" => "\\palh",
    "̢" => "\\rh",
    "̧" => "\\c",
    "̨" => "\\k",
    "̪" => "\\sbbrg",
    "̰" => "\\wideutilde",
    "̲" => "\\underbar",
    "̶" => "\\sout",
    "̸" => "\\not",
    "͍" => "\\underleftrightarrow",
    "Α" => "\\Alpha",
    "Β" => "\\Beta",
    "Γ" => "\\Gamma",
    "Δ" => "\\Delta",
    "Ε" => "\\Epsilon",
    "Ζ" => "\\Zeta",
    "Η" => "\\Eta",
    "Θ" => "\\Theta",
    "Ι" => "\\Iota",
    "Κ" => "\\Kappa",
    "Λ" => "\\Lambda",
    "Μ" => "\\upMu",
    "Ν" => "\\upNu",
    "Ξ" => "\\Xi",
    "Ο" => "\\upOmicron",
    "Π" => "\\Pi",
    "Ρ" => "\\Rho",
    "Σ" => "\\Sigma",
    "Τ" => "\\Tau",
    "Υ" => "\\Upsilon",
    "Φ" => "\\Phi",
    "Χ" => "\\Chi",
    "Ψ" => "\\Psi",
    "Ω" => "\\Omega",
    "α" => "\\alpha",
    "β" => "\\beta",
    "γ" => "\\gamma",
    "δ" => "\\delta",
    "ε" => "\\varepsilon",
    "ζ" => "\\zeta",
    "η" => "\\eta",
    "θ" => "\\theta",
    "ι" => "\\iota",
    "κ" => "\\kappa",
    "λ" => "\\lambda",
    "μ" => "\\mu",
    "ν" => "\\nu",
    "ξ" => "\\xi",
    "ο" => "\\upomicron",
    "π" => "\\pi",
    "ρ" => "\\rho",
    "ς" => "\\varsigma",
    "σ" => "\\sigma",
    "τ" => "\\tau",
    "υ" => "\\upsilon",
    "φ" => "\\varphi",
    "χ" => "\\chi",
    "ψ" => "\\psi",
    "ω" => "\\omega",
    "ϐ" => "\\upvarbeta",
    "ϑ" => "\\vartheta",
    "ϕ" => "\\phi",
    "ϖ" => "\\varpi",
    "Ϙ" => "\\upoldKoppa",
    "ϙ" => "\\upoldkoppa",
    "Ϛ" => "\\Stigma",
    "ϛ" => "\\upstigma",
    "Ϝ" => "\\Digamma",
    "ϝ" => "\\digamma",
    "Ϟ" => "\\Koppa",
    "ϟ" => "\\upkoppa",
    "Ϡ" => "\\Sampi",
    "ϡ" => "\\upsampi",
    "ϰ" => "\\varkappa",
    "ϱ" => "\\varrho",
    "ϴ" => "\\varTheta",
    "ϵ" => "\\epsilon",
    "϶" => "\\backepsilon",
    "ᴬ" => "\\^A",
    "ᴮ" => "\\^B",
    "ᴰ" => "\\^D",
    "ᴱ" => "\\^E",
    "ᴳ" => "\\^G",
    "ᴴ" => "\\^H",
    "ᴵ" => "\\^I",
    "ᴶ" => "\\^J",
    "ᴷ" => "\\^K",
    "ᴸ" => "\\^L",
    "ᴹ" => "\\^M",
    "ᴺ" => "\\^N",
    "ᴼ" => "\\^O",
    "ᴾ" => "\\^P",
    "ᴿ" => "\\^R",
    "ᵀ" => "\\^T",
    "ᵁ" => "\\^U",
    "ᵂ" => "\\^W",
    "ᵃ" => "\\^a",
    "ᵅ" => "\\^alpha",
    "ᵇ" => "\\^b",
    "ᵈ" => "\\^d",
    "ᵉ" => "\\^e",
    "ᵋ" => "\\^epsilon",
    "ᵍ" => "\\^g",
    "ᵏ" => "\\^k",
    "ᵐ" => "\\^m",
    "ᵒ" => "\\^o",
    "ᵖ" => "\\^p",
    "ᵗ" => "\\^t",
    "ᵘ" => "\\^u",
    "ᵛ" => "\\^v",
    "ᵝ" => "\\^beta",
    "ᵞ" => "\\^gamma",
    "ᵟ" => "\\^delta",
    "ᵠ" => "\\^phi",
    "ᵡ" => "\\^chi",
    "ᵢ" => "\\_i",
    "ᵣ" => "\\_r",
    "ᵤ" => "\\_u",
    "ᵥ" => "\\_v",
    "ᵦ" => "\\_beta",
    "ᵧ" => "\\_gamma",
    "ᵨ" => "\\_rho",
    "ᵩ" => "\\_phi",
    "ᵪ" => "\\_chi",
    "ᶜ" => "\\^c",
    "ᶠ" => "\\^f",
    "ᶥ" => "\\^iota",
    "ᶲ" => "\\^Phi",
    "ᶻ" => "\\^z",
    "ᶿ" => "\\^theta",
    " " => "\\enspace",
    " " => "\\quad",
    " " => "\\thickspace",
    " " => "\\thinspace",
    " " => "\\hspace",
    "–" => "\\endash",
    "—" => "\\emdash",
    "‖" => "\\Vert",
    "‘" => "\\lq",
    "’" => "\\rq",
    "‛" => "\\reapos",
    "“" => "\\quotedblleft",
    "”" => "\\quotedblright",
    "†" => "\\dagger",
    "‡" => "\\ddagger",
    "•" => "\\bullet",
    "…" => "\\ldots",
    "‰" => "\\perthousand",
    "‱" => "\\pertenthousand",
    "′" => "\\prime",
    "″" => "\\pprime",
    "‴" => "\\ppprime",
    "‵" => "\\backprime",
    "‶" => "\\backpprime",
    "‷" => "\\backppprime",
    "‹" => "\\guilsinglleft",
    "›" => "\\guilsinglright",
    "⁀" => "\\tieconcat",
    "⁗" => "\\pppprime",
    "⁝" => "\\tricolon",
    "\u2060" => "\\nolinebreak",
    "⁰" => "\\^0",
    "ⁱ" => "\\^i",
    "⁴" => "\\^4",
    "⁵" => "\\^5",
    "⁶" => "\\^6",
    "⁷" => "\\^7",
    "⁸" => "\\^8",
    "⁹" => "\\^9",
    "⁺" => "\\^+",
    "⁻" => "\\^-",
    "⁼" => "\\^=",
    "⁽" => "\\^(",
    "⁾" => "\\^)",
    "ⁿ" => "\\^n",
    "₀" => "\\_0",
    "₁" => "\\_1",
    "₂" => "\\_2",
    "₃" => "\\_3",
    "₄" => "\\_4",
    "₅" => "\\_5",
    "₆" => "\\_6",
    "₇" => "\\_7",
    "₈" => "\\_8",
    "₉" => "\\_9",
    "₊" => "\\_+",
    "₋" => "\\_-",
    "₌" => "\\_=",
    "₍" => "\\_(",
    "₎" => "\\_)",
    "ₐ" => "\\_a",
    "ₑ" => "\\_e",
    "ₒ" => "\\_o",
    "ₓ" => "\\_x",
    "ₔ" => "\\_schwa",
    "ₕ" => "\\_h",
    "ₖ" => "\\_k",
    "ₗ" => "\\_l",
    "ₘ" => "\\_m",
    "ₙ" => "\\_n",
    "ₚ" => "\\_p",
    "ₛ" => "\\_s",
    "ₜ" => "\\_t",
    "₧" => "\\pes",
    "€" => "\\euro",
    "⃐" => "\\leftharpoonaccent",
    "⃑" => "\\rightharpoonaccent",
    "⃒" => "\\vertoverlay",
    "⃖" => "\\overleftarrow",
    "⃗" => "\\vec",
    "⃛" => "\\dddot",
    "⃜" => "\\ddddot",
    "⃝" => "\\enclosecircle",
    "⃞" => "\\enclosesquare",
    "⃟" => "\\enclosediamond",
    "⃡" => "\\overleftrightarrow",
    "⃤" => "\\enclosetriangle",
    "⃧" => "\\annuity",
    "⃨" => "\\threeunderdot",
    "⃩" => "\\widebridgeabove",
    "⃬" => "\\underrightharpoondown",
    "⃭" => "\\underleftharpoondown",
    "⃮" => "\\underleftarrow",
    "⃯" => "\\underrightarrow",
    "⃰" => "\\asteraccent",
    "ℂ" => "\\bbC",
    "ℇ" => "\\eulermascheroni",
    "ℊ" => "\\scrg",
    "ℋ" => "\\scrH",
    "ℌ" => "\\frakH",
    "ℍ" => "\\bbH",
    "ℎ" => "\\planck",
    "ℏ" => "\\hslash",
    "ℐ" => "\\scrI",
    "ℑ" => "\\Im",
    "ℒ" => "\\scrL",
    "ℓ" => "\\ell",
    "ℕ" => "\\bbN",
    "№" => "\\numero",
    "℘" => "\\wp",
    "ℙ" => "\\bbP",
    "ℚ" => "\\bbQ",
    "ℛ" => "\\scrR",
    "ℜ" => "\\Re",
    "ℝ" => "\\bbR",
    "℞" => "\\xrat",
    "™" => "\\trademark",
    "ℤ" => "\\bbZ",
    "Ω" => "\\ohm",
    "℧" => "\\mho",
    "ℨ" => "\\frakZ",
    "℩" => "\\turnediota",
    "Å" => "\\Angstrom",
    "ℬ" => "\\scrB",
    "ℭ" => "\\frakC",
    "ℯ" => "\\euler",
    "ℰ" => "\\scrE",
    "ℱ" => "\\scrF",
    "Ⅎ" => "\\Finv",
    "ℳ" => "\\scrM",
    "ℴ" => "\\scro",
    "ℵ" => "\\aleph",
    "ℶ" => "\\beth",
    "ℷ" => "\\gimel",
    "ℸ" => "\\daleth",
    "ℼ" => "\\bbpi",
    "ℽ" => "\\bbgamma",
    "ℾ" => "\\bbGamma",
    "ℿ" => "\\bbPi",
    "⅀" => "\\bbsum",
    "⅁" => "\\Game",
    "⅂" => "\\sansLturned",
    "⅃" => "\\sansLmirrored",
    "⅄" => "\\Yup",
    "ⅅ" => "\\bbiD",
    "ⅆ" => "\\bbid",
    "ⅇ" => "\\bbie",
    "ⅈ" => "\\bbii",
    "ⅉ" => "\\bbij",
    "⅊" => "\\PropertyLine",
    "⅋" => "\\upand",
    "⅐" => "\\1/7",
    "⅑" => "\\1/9",
    "⅒" => "\\1/10",
    "⅓" => "\\1/3",
    "⅔" => "\\2/3",
    "⅕" => "\\1/5",
    "⅖" => "\\2/5",
    "⅗" => "\\3/5",
    "⅘" => "\\4/5",
    "⅙" => "\\1/6",
    "⅚" => "\\5/6",
    "⅛" => "\\1/8",
    "⅜" => "\\3/8",
    "⅝" => "\\5/8",
    "⅞" => "\\7/8",
    "⅟" => "\\1/",
    "↉" => "\\0/3",
    "←" => "\\leftarrow",
    "↑" => "\\uparrow",
    "→" => "\\rightarrow",
    "↓" => "\\downarrow",
    "↔" => "\\leftrightarrow",
    "↕" => "\\updownarrow",
    "↖" => "\\nwarrow",
    "↗" => "\\nearrow",
    "↘" => "\\searrow",
    "↙" => "\\swarrow",
    "↚" => "\\nleftarrow",
    "↛" => "\\nrightarrow",
    "↜" => "\\leftwavearrow",
    "↝" => "\\rightwavearrow",
    "↞" => "\\twoheadleftarrow",
    "↟" => "\\twoheaduparrow",
    "↠" => "\\twoheadrightarrow",
    "↡" => "\\twoheaddownarrow",
    "↢" => "\\leftarrowtail",
    "↣" => "\\rightarrowtail",
    "↤" => "\\mapsfrom",
    "↥" => "\\mapsup",
    "↦" => "\\mapsto",
    "↧" => "\\mapsdown",
    "↨" => "\\updownarrowbar",
    "↩" => "\\hookleftarrow",
    "↪" => "\\hookrightarrow",
    "↫" => "\\looparrowleft",
    "↬" => "\\looparrowright",
    "↭" => "\\leftrightsquigarrow",
    "↮" => "\\nleftrightarrow",
    "↯" => "\\downzigzagarrow",
    "↰" => "\\Lsh",
    "↱" => "\\Rsh",
    "↲" => "\\Ldsh",
    "↳" => "\\Rdsh",
    "↴" => "\\linefeed",
    "↵" => "\\carriagereturn",
    "↶" => "\\curvearrowleft",
    "↷" => "\\curvearrowright",
    "↸" => "\\barovernorthwestarrow",
    "↹" => "\\barleftarrowrightarrowbar",
    "↺" => "\\circlearrowleft",
    "↻" => "\\circlearrowright",
    "↼" => "\\leftharpoonup",
    "↽" => "\\leftharpoondown",
    "↾" => "\\upharpoonright",
    "↿" => "\\upharpoonleft",
    "⇀" => "\\rightharpoonup",
    "⇁" => "\\rightharpoondown",
    "⇂" => "\\downharpoonright",
    "⇃" => "\\downharpoonleft",
    "⇄" => "\\rightleftarrows",
    "⇅" => "\\dblarrowupdown",
    "⇆" => "\\leftrightarrows",
    "⇇" => "\\leftleftarrows",
    "⇈" => "\\upuparrows",
    "⇉" => "\\rightrightarrows",
    "⇊" => "\\downdownarrows",
    "⇋" => "\\leftrightharpoons",
    "⇌" => "\\rightleftharpoons",
    "⇍" => "\\nLeftarrow",
    "⇎" => "\\nLeftrightarrow",
    "⇏" => "\\nRightarrow",
    "⇐" => "\\Leftarrow",
    "⇑" => "\\Uparrow",
    "⇒" => "\\Rightarrow",
    "⇓" => "\\Downarrow",
    "⇔" => "\\Leftrightarrow",
    "⇕" => "\\Updownarrow",
    "⇖" => "\\Nwarrow",
    "⇗" => "\\Nearrow",
    "⇘" => "\\Searrow",
    "⇙" => "\\Swarrow",
    "⇚" => "\\Lleftarrow",
    "⇛" => "\\Rrightarrow",
    "⇜" => "\\leftsquigarrow",
    "⇝" => "\\rightsquigarrow",
    "⇞" => "\\nHuparrow",
    "⇟" => "\\nHdownarrow",
    "⇠" => "\\leftdasharrow",
    "⇡" => "\\updasharrow",
    "⇢" => "\\rightdasharrow",
    "⇣" => "\\downdasharrow",
    "⇤" => "\\barleftarrow",
    "⇥" => "\\rightarrowbar",
    "⇦" => "\\leftwhitearrow",
    "⇧" => "\\upwhitearrow",
    "⇨" => "\\rightwhitearrow",
    "⇩" => "\\downwhitearrow",
    "⇪" => "\\whitearrowupfrombar",
    "⇴" => "\\circleonrightarrow",
    "⇵" => "\\DownArrowUpArrow",
    "⇶" => "\\rightthreearrows",
    "⇷" => "\\nvleftarrow",
    "⇸" => "\\nvrightarrow",
    "⇹" => "\\nvleftrightarrow",
    "⇺" => "\\nVleftarrow",
    "⇻" => "\\nVrightarrow",
    "⇼" => "\\nVleftrightarrow",
    "⇽" => "\\leftarrowtriangle",
    "⇾" => "\\rightarrowtriangle",
    "⇿" => "\\leftrightarrowtriangle",
    "∀" => "\\forall",
    "∁" => "\\complement",
    "∂" => "\\partial",
    "∃" => "\\exists",
    "∄" => "\\nexists",
    "∅" => "\\emptyset",
    "∆" => "\\increment",
    "∇" => "\\nabla",
    "∈" => "\\in",
    "∉" => "\\notin",
    "∊" => "\\smallin",
    "∋" => "\\ni",
    "∌" => "\\nni",
    "∍" => "\\smallni",
    "∎" => "\\QED",
    "∏" => "\\prod",
    "∐" => "\\coprod",
    "∑" => "\\sum",
    "−" => "\\minus",
    "∓" => "\\mp",
    "∔" => "\\dotplus",
    "∖" => "\\setminus",
    "∗" => "\\ast",
    "∘" => "\\circ",
    "∙" => "\\vysmblkcircle",
    "√" => "\\sqrt",
    "∛" => "\\cbrt",
    "∜" => "\\fourthroot",
    "∝" => "\\propto",
    "∞" => "\\infty",
    "∟" => "\\rightangle",
    "∠" => "\\angle",
    "∡" => "\\measuredangle",
    "∢" => "\\sphericalangle",
    "∣" => "\\mid",
    "∤" => "\\nmid",
    "∥" => "\\parallel",
    "∦" => "\\nparallel",
    "∧" => "\\wedge",
    "∨" => "\\vee",
    "∩" => "\\cap",
    "∪" => "\\cup",
    "∫" => "\\int",
    "∬" => "\\iint",
    "∭" => "\\iiint",
    "∮" => "\\oint",
    "∯" => "\\oiint",
    "∰" => "\\oiiint",
    "∱" => "\\clwintegral",
    "∲" => "\\varointclockwise",
    "∳" => "\\ointctrclockwise",
    "∴" => "\\therefore",
    "∵" => "\\because",
    "∷" => "\\Colon",
    "∸" => "\\dotminus",
    "∺" => "\\dotsminusdots",
    "∻" => "\\kernelcontraction",
    "∼" => "\\sim",
    "∽" => "\\backsim",
    "∾" => "\\lazysinv",
    "∿" => "\\sinewave",
    "≀" => "\\wr",
    "≁" => "\\nsim",
    "≂" => "\\eqsim",
    "≂̸" => "\\neqsim",
    "≃" => "\\simeq",
    "≄" => "\\nsime",
    "≅" => "\\cong",
    "≆" => "\\approxnotequal",
    "≇" => "\\ncong",
    "≈" => "\\approx",
    "≉" => "\\napprox",
    "≊" => "\\approxeq",
    "≋" => "\\tildetrpl",
    "≌" => "\\allequal",
    "≍" => "\\asymp",
    "≎" => "\\Bumpeq",
    "≎̸" => "\\nBumpeq",
    "≏" => "\\bumpeq",
    "≏̸" => "\\nbumpeq",
    "≐" => "\\doteq",
    "≑" => "\\Doteq",
    "≒" => "\\fallingdotseq",
    "≓" => "\\risingdotseq",
    "≔" => "\\coloneq",
    "≕" => "\\eqcolon",
    "≖" => "\\eqcirc",
    "≗" => "\\circeq",
    "≘" => "\\arceq",
    "≙" => "\\wedgeq",
    "≚" => "\\veeeq",
    "≛" => "\\starequal",
    "≜" => "\\triangleq",
    "≝" => "\\eqdef",
    "≞" => "\\measeq",
    "≟" => "\\questeq",
    "≠" => "\\ne",
    "≡" => "\\equiv",
    "≢" => "\\nequiv",
    "≣" => "\\Equiv",
    "≤" => "\\leq",
    "≥" => "\\geq",
    "≦" => "\\leqq",
    "≧" => "\\geqq",
    "≨" => "\\lneqq",
    "≨" => "\\lvertneqq",
    "≩" => "\\gneqq",
    "≩" => "\\gvertneqq",
    "≪" => "\\ll",
    "≪̸" => "\\NotLessLess",
    "≫" => "\\gg",
    "≫̸" => "\\NotGreaterGreater",
    "≬" => "\\between",
    "≭" => "\\nasymp",
    "≮" => "\\nless",
    "≯" => "\\ngtr",
    "≰" => "\\nleq",
    "≱" => "\\ngeq",
    "≲" => "\\lesssim",
    "≳" => "\\gtrsim",
    "≴" => "\\nlesssim",
    "≵" => "\\ngtrsim",
    "≶" => "\\lessgtr",
    "≷" => "\\gtrless",
    "≸" => "\\notlessgreater",
    "≹" => "\\notgreaterless",
    "≺" => "\\prec",
    "≻" => "\\succ",
    "≼" => "\\preccurlyeq",
    "≽" => "\\succcurlyeq",
    "≾" => "\\precsim",
    "≾̸" => "\\nprecsim",
    "≿" => "\\succsim",
    "≿̸" => "\\nsuccsim",
    "⊀" => "\\nprec",
    "⊁" => "\\nsucc",
    "⊂" => "\\subset",
    "⊃" => "\\supset",
    "⊄" => "\\nsubset",
    "⊅" => "\\nsupset",
    "⊆" => "\\subseteq",
    "⊇" => "\\supseteq",
    "⊈" => "\\nsubseteq",
    "⊉" => "\\nsupseteq",
    "⊊" => "\\subsetneq",
    "⊊" => "\\varsubsetneqq",
    "⊋" => "\\supsetneq",
    "⊋" => "\\varsupsetneq",
    "⊍" => "\\cupdot",
    "⊎" => "\\uplus",
    "⊏" => "\\sqsubset",
    "⊏̸" => "\\NotSquareSubset",
    "⊐" => "\\sqsupset",
    "⊐̸" => "\\NotSquareSuperset",
    "⊑" => "\\sqsubseteq",
    "⊒" => "\\sqsupseteq",
    "⊓" => "\\sqcap",
    "⊔" => "\\sqcup",
    "⊕" => "\\oplus",
    "⊖" => "\\ominus",
    "⊗" => "\\otimes",
    "⊘" => "\\oslash",
    "⊙" => "\\odot",
    "⊚" => "\\circledcirc",
    "⊛" => "\\circledast",
    "⊜" => "\\circledequal",
    "⊝" => "\\circleddash",
    "⊞" => "\\boxplus",
    "⊟" => "\\boxminus",
    "⊠" => "\\boxtimes",
    "⊡" => "\\boxdot",
    "⊢" => "\\vdash",
    "⊣" => "\\dashv",
    "⊤" => "\\top",
    "⊥" => "\\bot",
    "⊧" => "\\models",
    "⊨" => "\\vDash",
    "⊩" => "\\Vdash",
    "⊪" => "\\Vvdash",
    "⊫" => "\\VDash",
    "⊬" => "\\nvdash",
    "⊭" => "\\nvDash",
    "⊮" => "\\nVdash",
    "⊯" => "\\nVDash",
    "⊰" => "\\prurel",
    "⊱" => "\\scurel",
    "⊲" => "\\vartriangleleft",
    "⊳" => "\\vartriangleright",
    "⊴" => "\\trianglelefteq",
    "⊵" => "\\trianglerighteq",
    "⊶" => "\\original",
    "⊷" => "\\image",
    "⊸" => "\\multimap",
    "⊹" => "\\hermitconjmatrix",
    "⊺" => "\\intercal",
    "⊻" => "\\xor",
    "⊼" => "\\barwedge",
    "⊽" => "\\barvee",
    "⊾" => "\\rightanglearc",
    "⊿" => "\\varlrtriangle",
    "⋀" => "\\bigwedge",
    "⋁" => "\\bigvee",
    "⋂" => "\\bigcap",
    "⋃" => "\\bigcup",
    "⋄" => "\\diamond",
    "⋅" => "\\cdot",
    "⋆" => "\\star",
    "⋇" => "\\divideontimes",
    "⋈" => "\\bowtie",
    "⋉" => "\\ltimes",
    "⋊" => "\\rtimes",
    "⋋" => "\\leftthreetimes",
    "⋌" => "\\rightthreetimes",
    "⋍" => "\\backsimeq",
    "⋎" => "\\curlyvee",
    "⋏" => "\\curlywedge",
    "⋐" => "\\Subset",
    "⋑" => "\\Supset",
    "⋒" => "\\Cap",
    "⋓" => "\\Cup",
    "⋔" => "\\pitchfork",
    "⋕" => "\\equalparallel",
    "⋖" => "\\lessdot",
    "⋗" => "\\gtrdot",
    "⋘" => "\\verymuchless",
    "⋙" => "\\ggg",
    "⋚" => "\\lesseqgtr",
    "⋛" => "\\gtreqless",
    "⋜" => "\\eqless",
    "⋝" => "\\eqgtr",
    "⋞" => "\\curlyeqprec",
    "⋟" => "\\curlyeqsucc",
    "⋠" => "\\npreccurlyeq",
    "⋡" => "\\nsucccurlyeq",
    "⋢" => "\\nsqsubseteq",
    "⋣" => "\\nsqsupseteq",
    "⋤" => "\\sqsubsetneq",
    "⋥" => "\\sqspne",
    "⋦" => "\\lnsim",
    "⋧" => "\\gnsim",
    "⋨" => "\\precnsim",
    "⋩" => "\\succnsim",
    "⋪" => "\\ntriangleleft",
    "⋫" => "\\ntriangleright",
    "⋬" => "\\ntrianglelefteq",
    "⋭" => "\\ntrianglerighteq",
    "⋮" => "\\vdots",
    "⋯" => "\\cdots",
    "⋰" => "\\adots",
    "⋱" => "\\ddots",
    "⋲" => "\\disin",
    "⋳" => "\\varisins",
    "⋴" => "\\isins",
    "⋵" => "\\isindot",
    "⋶" => "\\varisinobar",
    "⋷" => "\\isinobar",
    "⋸" => "\\isinvb",
    "⋹" => "\\isinE",
    "⋺" => "\\nisd",
    "⋻" => "\\varnis",
    "⋼" => "\\nis",
    "⋽" => "\\varniobar",
    "⋾" => "\\niobar",
    "⋿" => "\\bagmember",
    "⌀" => "\\diameter",
    "⌂" => "\\house",
    "⌅" => "\\varbarwedge",
    "⌆" => "\\vardoublebarwedge",
    "⌈" => "\\lceil",
    "⌉" => "\\rceil",
    "⌊" => "\\lfloor",
    "⌋" => "\\rfloor",
    "⌐" => "\\invnot",
    "⌑" => "\\sqlozenge",
    "⌒" => "\\profline",
    "⌓" => "\\profsurf",
    "⌕" => "\\recorder",
    "⌗" => "\\viewdata",
    "⌙" => "\\turnednot",
    "⌜" => "\\ulcorner",
    "⌝" => "\\urcorner",
    "⌞" => "\\llcorner",
    "⌟" => "\\lrcorner",
    "⌢" => "\\frown",
    "⌣" => "\\smile",
    "⌬" => "\\varhexagonlrbonds",
    "⌲" => "\\conictaper",
    "⌶" => "\\topbot",
    "⌽" => "\\obar",
    "⌿" => "\\notslash",
    "⍀" => "\\notbackslash",
    "⍓" => "\\boxupcaret",
    "⍰" => "\\boxquestion",
    "⎔" => "\\hexagon",
    "⎣" => "\\dlcorn",
    "⎰" => "\\lmoustache",
    "⎱" => "\\rmoustache",
    "⎴" => "\\overbracket",
    "⎵" => "\\underbracket",
    "⎶" => "\\bbrktbrk",
    "⎷" => "\\sqrtbottom",
    "⎸" => "\\lvboxline",
    "⎹" => "\\rvboxline",
    "⏎" => "\\varcarriagereturn",
    "⏞" => "\\overbrace",
    "⏟" => "\\underbrace",
    "⏢" => "\\trapezium",
    "⏣" => "\\benzenr",
    "⏤" => "\\strns",
    "⏥" => "\\fltns",
    "⏦" => "\\accurrent",
    "⏧" => "\\elinters",
    "␢" => "\\blanksymbol",
    "␣" => "\\visiblespace",
    "Ⓢ" => "\\circledS",
    "┆" => "\\dshfnc",
    "┙" => "\\sqfnw",
    "╱" => "\\diagup",
    "╲" => "\\diagdown",
    "▀" => "\\blockuphalf",
    "▄" => "\\blocklowhalf",
    "█" => "\\blockfull",
    "▌" => "\\blocklefthalf",
    "▐" => "\\blockrighthalf",
    "░" => "\\blockqtrshaded",
    "▒" => "\\blockhalfshaded",
    "▓" => "\\blockthreeqtrshaded",
    "■" => "\\blacksquare",
    "□" => "\\square",
    "▢" => "\\squoval",
    "▣" => "\\blackinwhitesquare",
    "▤" => "\\squarehfill",
    "▥" => "\\squarevfill",
    "▦" => "\\squarehvfill",
    "▧" => "\\squarenwsefill",
    "▨" => "\\squareneswfill",
    "▩" => "\\squarecrossfill",
    "▪" => "\\smblksquare",
    "▫" => "\\smwhtsquare",
    "▬" => "\\hrectangleblack",
    "▭" => "\\hrectangle",
    "▮" => "\\vrectangleblack",
    "▯" => "\\vrecto",
    "▰" => "\\parallelogramblack",
    "▱" => "\\parallelogram",
    "▲" => "\\bigblacktriangleup",
    "△" => "\\bigtriangleup",
    "▴" => "\\blacktriangle",
    "▵" => "\\vartriangle",
    "▶" => "\\blacktriangleright",
    "▷" => "\\triangleright",
    "▸" => "\\smallblacktriangleright",
    "▹" => "\\smalltriangleright",
    "►" => "\\blackpointerright",
    "▻" => "\\whitepointerright",
    "▼" => "\\bigblacktriangledown",
    "▽" => "\\bigtriangledown",
    "▾" => "\\blacktriangledown",
    "▿" => "\\triangledown",
    "◀" => "\\blacktriangleleft",
    "◁" => "\\triangleleft",
    "◂" => "\\smallblacktriangleleft",
    "◃" => "\\smalltriangleleft",
    "◄" => "\\blackpointerleft",
    "◅" => "\\whitepointerleft",
    "◆" => "\\mdlgblkdiamond",
    "◇" => "\\mdlgwhtdiamond",
    "◈" => "\\blackinwhitediamond",
    "◉" => "\\fisheye",
    "◊" => "\\lozenge",
    "○" => "\\bigcirc",
    "◌" => "\\dottedcircle",
    "◍" => "\\circlevertfill",
    "◎" => "\\bullseye",
    "●" => "\\mdlgblkcircle",
    "◐" => "\\cirfl",
    "◑" => "\\cirfr",
    "◒" => "\\cirfb",
    "◓" => "\\circletophalfblack",
    "◔" => "\\circleurquadblack",
    "◕" => "\\blackcircleulquadwhite",
    "◖" => "\\blacklefthalfcircle",
    "◗" => "\\blackrighthalfcircle",
    "◘" => "\\rvbull",
    "◙" => "\\inversewhitecircle",
    "◚" => "\\invwhiteupperhalfcircle",
    "◛" => "\\invwhitelowerhalfcircle",
    "◜" => "\\ularc",
    "◝" => "\\urarc",
    "◞" => "\\lrarc",
    "◟" => "\\llarc",
    "◠" => "\\topsemicircle",
    "◡" => "\\botsemicircle",
    "◢" => "\\lrblacktriangle",
    "◣" => "\\llblacktriangle",
    "◤" => "\\ulblacktriangle",
    "◥" => "\\urblacktriangle",
    "◦" => "\\smwhtcircle",
    "◧" => "\\sqfl",
    "◨" => "\\sqfr",
    "◩" => "\\squareulblack",
    "◪" => "\\sqfse",
    "◫" => "\\boxbar",
    "◬" => "\\trianglecdot",
    "◭" => "\\triangleleftblack",
    "◮" => "\\trianglerightblack",
    "◯" => "\\lgwhtcircle",
    "◰" => "\\squareulquad",
    "◱" => "\\squarellquad",
    "◲" => "\\squarelrquad",
    "◳" => "\\squareurquad",
    "◴" => "\\circleulquad",
    "◵" => "\\circlellquad",
    "◶" => "\\circlelrquad",
    "◷" => "\\circleurquad",
    "◸" => "\\ultriangle",
    "◹" => "\\urtriangle",
    "◺" => "\\lltriangle",
    "◻" => "\\mdwhtsquare",
    "◼" => "\\mdblksquare",
    "◽" => "\\mdsmwhtsquare",
    "◾" => "\\mdsmblksquare",
    "◿" => "\\lrtriangle",
    "★" => "\\bigstar",
    "☆" => "\\bigwhitestar",
    "☉" => "\\astrosun",
    "☡" => "\\danger",
    "☻" => "\\blacksmiley",
    "☼" => "\\sun",
    "☽" => "\\rightmoon",
    "☾" => "\\leftmoon",
    "☿" => "\\mercury",
    "♀" => "\\female",
    "♂" => "\\mars",
    "♃" => "\\jupiter",
    "♄" => "\\saturn",
    "♅" => "\\uranus",
    "♆" => "\\neptune",
    "♇" => "\\pluto",
    "♈" => "\\aries",
    "♉" => "\\taurus",
    "♊" => "\\gemini",
    "♋" => "\\cancer",
    "♌" => "\\leo",
    "♍" => "\\virgo",
    "♎" => "\\libra",
    "♏" => "\\scorpio",
    "♐" => "\\sagittarius",
    "♑" => "\\capricornus",
    "♒" => "\\aquarius",
    "♓" => "\\pisces",
    "♠" => "\\spadesuit",
    "♡" => "\\heartsuit",
    "♢" => "\\diamondsuit",
    "♣" => "\\clubsuit",
    "♤" => "\\varspadesuit",
    "♥" => "\\varheartsuit",
    "♦" => "\\vardiamondsuit",
    "♧" => "\\varclubsuit",
    "♩" => "\\quarternote",
    "♪" => "\\eighthnote",
    "♫" => "\\twonotes",
    "♭" => "\\flat",
    "♮" => "\\natural",
    "♯" => "\\sharp",
    "♾" => "\\acidfree",
    "⚀" => "\\dicei",
    "⚁" => "\\diceii",
    "⚂" => "\\diceiii",
    "⚃" => "\\diceiv",
    "⚄" => "\\dicev",
    "⚅" => "\\dicevi",
    "⚆" => "\\circledrightdot",
    "⚇" => "\\circledtwodots",
    "⚈" => "\\blackcircledrightdot",
    "⚉" => "\\blackcircledtwodots",
    "⚥" => "\\hermaphrodite",
    "⚪" => "\\mdwhtcircle",
    "⚫" => "\\mdblkcircle",
    "⚬" => "\\mdsmwhtcircle",
    "⚲" => "\\neuter",
    "✓" => "\\checkmark",
    "✠" => "\\maltese",
    "✪" => "\\circledstar",
    "✶" => "\\varstar",
    "✽" => "\\dingasterisk",
    "➛" => "\\draftingarrow",
    "⟀" => "\\threedangle",
    "⟁" => "\\whiteinwhitetriangle",
    "⟂" => "\\perp",
    "⟈" => "\\bsolhsub",
    "⟉" => "\\suphsol",
    "⟑" => "\\wedgedot",
    "⟒" => "\\upin",
    "⟕" => "\\leftouterjoin",
    "⟖" => "\\rightouterjoin",
    "⟗" => "\\fullouterjoin",
    "⟘" => "\\bigbot",
    "⟙" => "\\bigtop",
    "⟦" => "\\openbracketleft",
    "⟧" => "\\rrbracket",
    "⟨" => "\\langle",
    "⟩" => "\\rangle",
    "⟰" => "\\UUparrow",
    "⟱" => "\\DDownarrow",
    "⟵" => "\\longleftarrow",
    "⟶" => "\\longrightarrow",
    "⟷" => "\\longleftrightarrow",
    "⟸" => "\\Longleftarrow",
    "⟹" => "\\Longrightarrow",
    "⟺" => "\\iff",
    "⟻" => "\\longmapsfrom",
    "⟼" => "\\longmapsto",
    "⟽" => "\\Longmapsfrom",
    "⟾" => "\\Longmapsto",
    "⟿" => "\\longrightsquigarrow",
    "⤀" => "\\nvtwoheadrightarrow",
    "⤁" => "\\nVtwoheadrightarrow",
    "⤂" => "\\nvLeftarrow",
    "⤃" => "\\nvRightarrow",
    "⤄" => "\\nvLeftrightarrow",
    "⤅" => "\\twoheadmapsto",
    "⤆" => "\\Mapsfrom",
    "⤇" => "\\Mapsto",
    "⤈" => "\\downarrowbarred",
    "⤉" => "\\uparrowbarred",
    "⤊" => "\\Uuparrow",
    "⤋" => "\\Ddownarrow",
    "⤌" => "\\leftbkarrow",
    "⤍" => "\\bkarow",
    "⤎" => "\\leftdbkarrow",
    "⤏" => "\\dbkarow",
    "⤐" => "\\drbkarrow",
    "⤑" => "\\rightdotarrow",
    "⤒" => "\\UpArrowBar",
    "⤓" => "\\DownArrowBar",
    "⤔" => "\\nvrightarrowtail",
    "⤕" => "\\nVrightarrowtail",
    "⤖" => "\\twoheadrightarrowtail",
    "⤗" => "\\nvtwoheadrightarrowtail",
    "⤘" => "\\nVtwoheadrightarrowtail",
    "⤝" => "\\diamondleftarrow",
    "⤞" => "\\rightarrowdiamond",
    "⤟" => "\\diamondleftarrowbar",
    "⤠" => "\\barrightarrowdiamond",
    "⤥" => "\\hksearow",
    "⤦" => "\\hkswarow",
    "⤧" => "\\tona",
    "⤨" => "\\toea",
    "⤩" => "\\tosa",
    "⤪" => "\\towa",
    "⤫" => "\\rdiagovfdiag",
    "⤬" => "\\fdiagovrdiag",
    "⤭" => "\\seovnearrow",
    "⤮" => "\\neovsearrow",
    "⤯" => "\\fdiagovnearrow",
    "⤰" => "\\rdiagovsearrow",
    "⤱" => "\\neovnwarrow",
    "⤲" => "\\nwovnearrow",
    "⥂" => "\\Rlarr",
    "⥄" => "\\rLarr",
    "⥅" => "\\rightarrowplus",
    "⥆" => "\\leftarrowplus",
    "⥇" => "\\rarrx",
    "⥈" => "\\leftrightarrowcircle",
    "⥉" => "\\twoheaduparrowcircle",
    "⥊" => "\\leftrightharpoonupdown",
    "⥋" => "\\leftrightharpoondownup",
    "⥌" => "\\updownharpoonrightleft",
    "⥍" => "\\updownharpoonleftright",
    "⥎" => "\\LeftRightVector",
    "⥏" => "\\RightUpDownVector",
    "⥐" => "\\DownLeftRightVector",
    "⥑" => "\\LeftUpDownVector",
    "⥒" => "\\LeftVectorBar",
    "⥓" => "\\RightVectorBar",
    "⥔" => "\\RightUpVectorBar",
    "⥕" => "\\RightDownVectorBar",
    "⥖" => "\\DownLeftVectorBar",
    "⥗" => "\\DownRightVectorBar",
    "⥘" => "\\LeftUpVectorBar",
    "⥙" => "\\LeftDownVectorBar",
    "⥚" => "\\LeftTeeVector",
    "⥛" => "\\RightTeeVector",
    "⥜" => "\\RightUpTeeVector",
    "⥝" => "\\RightDownTeeVector",
    "⥞" => "\\DownLeftTeeVector",
    "⥟" => "\\DownRightTeeVector",
    "⥠" => "\\LeftUpTeeVector",
    "⥡" => "\\LeftDownTeeVector",
    "⥢" => "\\leftharpoonsupdown",
    "⥣" => "\\upharpoonsleftright",
    "⥤" => "\\rightharpoonsupdown",
    "⥥" => "\\downharpoonsleftright",
    "⥦" => "\\leftrightharpoonsup",
    "⥧" => "\\leftrightharpoonsdown",
    "⥨" => "\\rightleftharpoonsup",
    "⥩" => "\\rightleftharpoonsdown",
    "⥪" => "\\leftharpoonupdash",
    "⥫" => "\\dashleftharpoondown",
    "⥬" => "\\rightharpoonupdash",
    "⥭" => "\\dashrightharpoondown",
    "⥮" => "\\UpEquilibrium",
    "⥯" => "\\ReverseUpEquilibrium",
    "⥰" => "\\RoundImplies",
    "⦀" => "\\Vvert",
    "⦆" => "\\Elroang",
    "⦙" => "\\ddfnc",
    "⦛" => "\\measuredangleleft",
    "⦜" => "\\Angle",
    "⦝" => "\\rightanglemdot",
    "⦞" => "\\angles",
    "⦟" => "\\angdnr",
    "⦠" => "\\lpargt",
    "⦡" => "\\sphericalangleup",
    "⦢" => "\\turnangle",
    "⦣" => "\\revangle",
    "⦤" => "\\angleubar",
    "⦥" => "\\revangleubar",
    "⦦" => "\\wideangledown",
    "⦧" => "\\wideangleup",
    "⦨" => "\\measanglerutone",
    "⦩" => "\\measanglelutonw",
    "⦪" => "\\measanglerdtose",
    "⦫" => "\\measangleldtosw",
    "⦬" => "\\measangleurtone",
    "⦭" => "\\measangleultonw",
    "⦮" => "\\measangledrtose",
    "⦯" => "\\measangledltosw",
    "⦰" => "\\revemptyset",
    "⦱" => "\\emptysetobar",
    "⦲" => "\\emptysetocirc",
    "⦳" => "\\emptysetoarr",
    "⦴" => "\\emptysetoarrl",
    "⦷" => "\\circledparallel",
    "⦸" => "\\obslash",
    "⦼" => "\\odotslashdot",
    "⦾" => "\\circledwhitebullet",
    "⦿" => "\\circledbullet",
    "⧀" => "\\olessthan",
    "⧁" => "\\ogreaterthan",
    "⧄" => "\\boxdiag",
    "⧅" => "\\boxbslash",
    "⧆" => "\\boxast",
    "⧇" => "\\boxcircle",
    "⧊" => "\\Lap",
    "⧋" => "\\defas",
    "⧏" => "\\LeftTriangleBar",
    "⧏̸" => "\\NotLeftTriangleBar",
    "⧐" => "\\RightTriangleBar",
    "⧐̸" => "\\NotRightTriangleBar",
    "⧟" => "\\dualmap",
    "⧡" => "\\lrtriangleeq",
    "⧢" => "\\shuffle",
    "⧣" => "\\eparsl",
    "⧤" => "\\smeparsl",
    "⧥" => "\\eqvparsl",
    "⧫" => "\\blacklozenge",
    "⧴" => "\\RuleDelayed",
    "⧶" => "\\dsol",
    "⧷" => "\\rsolbar",
    "⧺" => "\\doubleplus",
    "⧻" => "\\tripleplus",
    "⨀" => "\\bigodot",
    "⨁" => "\\bigoplus",
    "⨂" => "\\bigotimes",
    "⨃" => "\\bigcupdot",
    "⨄" => "\\biguplus",
    "⨅" => "\\bigsqcap",
    "⨆" => "\\bigsqcup",
    "⨇" => "\\conjquant",
    "⨈" => "\\disjquant",
    "⨉" => "\\bigtimes",
    "⨊" => "\\modtwosum",
    "⨋" => "\\sumint",
    "⨌" => "\\iiiint",
    "⨍" => "\\intbar",
    "⨎" => "\\intBar",
    "⨏" => "\\clockoint",
    "⨐" => "\\cirfnint",
    "⨑" => "\\awint",
    "⨒" => "\\rppolint",
    "⨓" => "\\scpolint",
    "⨔" => "\\npolint",
    "⨕" => "\\pointint",
    "⨖" => "\\sqrint",
    "⨘" => "\\intx",
    "⨙" => "\\intcap",
    "⨚" => "\\intcup",
    "⨛" => "\\upint",
    "⨜" => "\\lowint",
    "⨝" => "\\join",
    "⨟" => "\\bbsemi",
    "⨢" => "\\ringplus",
    "⨣" => "\\plushat",
    "⨤" => "\\simplus",
    "⨥" => "\\plusdot",
    "⨦" => "\\plussim",
    "⨧" => "\\plussubtwo",
    "⨨" => "\\plustrif",
    "⨩" => "\\commaminus",
    "⨪" => "\\minusdot",
    "⨫" => "\\minusfdots",
    "⨬" => "\\minusrdots",
    "⨭" => "\\opluslhrim",
    "⨮" => "\\oplusrhrim",
    "⨯" => "\\Times",
    "⨰" => "\\dottimes",
    "⨱" => "\\timesbar",
    "⨲" => "\\btimes",
    "⨳" => "\\smashtimes",
    "⨴" => "\\otimeslhrim",
    "⨵" => "\\otimesrhrim",
    "⨶" => "\\otimeshat",
    "⨷" => "\\Otimes",
    "⨸" => "\\odiv",
    "⨹" => "\\triangleplus",
    "⨺" => "\\triangleminus",
    "⨻" => "\\triangletimes",
    "⨼" => "\\intprod",
    "⨽" => "\\intprodr",
    "⨿" => "\\amalg",
    "⩀" => "\\capdot",
    "⩁" => "\\uminus",
    "⩂" => "\\barcup",
    "⩃" => "\\barcap",
    "⩄" => "\\capwedge",
    "⩅" => "\\cupvee",
    "⩊" => "\\twocups",
    "⩋" => "\\twocaps",
    "⩌" => "\\closedvarcup",
    "⩍" => "\\closedvarcap",
    "⩎" => "\\Sqcap",
    "⩏" => "\\Sqcup",
    "⩐" => "\\closedvarcupsmashprod",
    "⩑" => "\\wedgeodot",
    "⩒" => "\\veeodot",
    "⩓" => "\\And",
    "⩔" => "\\Or",
    "⩕" => "\\wedgeonwedge",
    "⩖" => "\\ElOr",
    "⩗" => "\\bigslopedvee",
    "⩘" => "\\bigslopedwedge",
    "⩚" => "\\wedgemidvert",
    "⩛" => "\\veemidvert",
    "⩜" => "\\midbarwedge",
    "⩝" => "\\midbarvee",
    "⩞" => "\\perspcorrespond",
    "⩟" => "\\minhat",
    "⩠" => "\\wedgedoublebar",
    "⩡" => "\\varveebar",
    "⩢" => "\\doublebarvee",
    "⩣" => "\\veedoublebar",
    "⩦" => "\\eqdot",
    "⩧" => "\\dotequiv",
    "⩪" => "\\dotsim",
    "⩫" => "\\simrdots",
    "⩬" => "\\simminussim",
    "⩭" => "\\congdot",
    "⩮" => "\\asteq",
    "⩯" => "\\hatapprox",
    "⩰" => "\\approxeqq",
    "⩱" => "\\eqqplus",
    "⩲" => "\\pluseqq",
    "⩳" => "\\eqqsim",
    "⩴" => "\\Coloneq",
    "⩵" => "\\Equal",
    "⩶" => "\\eqeqeq",
    "⩷" => "\\ddotseq",
    "⩸" => "\\equivDD",
    "⩹" => "\\ltcir",
    "⩺" => "\\gtcir",
    "⩻" => "\\ltquest",
    "⩼" => "\\gtquest",
    "⩽" => "\\leqslant",
    "⩽̸" => "\\nleqslant",
    "⩾" => "\\geqslant",
    "⩾̸" => "\\ngeqslant",
    "⩿" => "\\lesdot",
    "⪀" => "\\gesdot",
    "⪁" => "\\lesdoto",
    "⪂" => "\\gesdoto",
    "⪃" => "\\lesdotor",
    "⪄" => "\\gesdotol",
    "⪅" => "\\lessapprox",
    "⪆" => "\\gtrapprox",
    "⪇" => "\\lneq",
    "⪈" => "\\gneq",
    "⪉" => "\\lnapprox",
    "⪊" => "\\gnapprox",
    "⪋" => "\\lesseqqgtr",
    "⪌" => "\\gtreqqless",
    "⪍" => "\\lsime",
    "⪎" => "\\gsime",
    "⪏" => "\\lsimg",
    "⪐" => "\\gsiml",
    "⪑" => "\\lgE",
    "⪒" => "\\glE",
    "⪓" => "\\lesges",
    "⪔" => "\\gesles",
    "⪕" => "\\eqslantless",
    "⪖" => "\\eqslantgtr",
    "⪗" => "\\elsdot",
    "⪘" => "\\egsdot",
    "⪙" => "\\eqqless",
    "⪚" => "\\eqqgtr",
    "⪛" => "\\eqqslantless",
    "⪜" => "\\eqqslantgtr",
    "⪝" => "\\simless",
    "⪞" => "\\simgtr",
    "⪟" => "\\simlE",
    "⪠" => "\\simgE",
    "⪡" => "\\NestedLessLess",
    "⪡̸" => "\\NotNestedLessLess",
    "⪢" => "\\NestedGreaterGreater",
    "⪢̸" => "\\NotNestedGreaterGreater",
    "⪣" => "\\partialmeetcontraction",
    "⪤" => "\\glj",
    "⪥" => "\\gla",
    "⪦" => "\\ltcc",
    "⪧" => "\\gtcc",
    "⪨" => "\\lescc",
    "⪩" => "\\gescc",
    "⪪" => "\\smt",
    "⪫" => "\\lat",
    "⪬" => "\\smte",
    "⪭" => "\\late",
    "⪮" => "\\bumpeqq",
    "⪯" => "\\preceq",
    "⪯̸" => "\\npreceq",
    "⪰" => "\\succeq",
    "⪰̸" => "\\nsucceq",
    "⪱" => "\\precneq",
    "⪲" => "\\succneq",
    "⪳" => "\\preceqq",
    "⪴" => "\\succeqq",
    "⪵" => "\\precneqq",
    "⪶" => "\\succneqq",
    "⪷" => "\\precapprox",
    "⪸" => "\\succapprox",
    "⪹" => "\\precnapprox",
    "⪺" => "\\succnapprox",
    "⪻" => "\\Prec",
    "⪼" => "\\Succ",
    "⪽" => "\\subsetdot",
    "⪾" => "\\supsetdot",
    "⪿" => "\\subsetplus",
    "⫀" => "\\supsetplus",
    "⫁" => "\\submult",
    "⫂" => "\\supmult",
    "⫃" => "\\subedot",
    "⫄" => "\\supedot",
    "⫅" => "\\subseteqq",
    "⫅̸" => "\\nsubseteqq",
    "⫆" => "\\supseteqq",
    "⫆̸" => "\\nsupseteqq",
    "⫇" => "\\subsim",
    "⫈" => "\\supsim",
    "⫉" => "\\subsetapprox",
    "⫊" => "\\supsetapprox",
    "⫋" => "\\subsetneqq",
    "⫌" => "\\supsetneqq",
    "⫍" => "\\lsqhook",
    "⫎" => "\\rsqhook",
    "⫏" => "\\csub",
    "⫐" => "\\csup",
    "⫑" => "\\csube",
    "⫒" => "\\csupe",
    "⫓" => "\\subsup",
    "⫔" => "\\supsub",
    "⫕" => "\\subsub",
    "⫖" => "\\supsup",
    "⫗" => "\\suphsub",
    "⫘" => "\\supdsub",
    "⫙" => "\\forkv",
    "⫛" => "\\mlcp",
    "⫝̸" => "\\forks",
    "⫝" => "\\forksnot",
    "⫣" => "\\dashV",
    "⫤" => "\\Dashv",
    "⫴" => "\\interleave",
    "⫶" => "\\tdcol",
    "⫷" => "\\lllnest",
    "⫸" => "\\gggnest",
    "⫹" => "\\leqqslant",
    "⫺" => "\\geqqslant",
    "⬒" => "\\squaretopblack",
    "⬓" => "\\squarebotblack",
    "⬔" => "\\squareurblack",
    "⬕" => "\\squarellblack",
    "⬖" => "\\diamondleftblack",
    "⬗" => "\\diamondrightblack",
    "⬘" => "\\diamondtopblack",
    "⬙" => "\\diamondbotblack",
    "⬚" => "\\dottedsquare",
    "⬛" => "\\lgblksquare",
    "⬜" => "\\lgwhtsquare",
    "⬝" => "\\vysmblksquare",
    "⬞" => "\\vysmwhtsquare",
    "⬟" => "\\pentagonblack",
    "⬠" => "\\pentagon",
    "⬡" => "\\varhexagon",
    "⬢" => "\\varhexagonblack",
    "⬣" => "\\hexagonblack",
    "⬤" => "\\lgblkcircle",
    "⬥" => "\\mdblkdiamond",
    "⬦" => "\\mdwhtdiamond",
    "⬧" => "\\mdblklozenge",
    "⬨" => "\\mdwhtlozenge",
    "⬩" => "\\smblkdiamond",
    "⬪" => "\\smblklozenge",
    "⬫" => "\\smwhtlozenge",
    "⬬" => "\\blkhorzoval",
    "⬭" => "\\whthorzoval",
    "⬮" => "\\blkvertoval",
    "⬯" => "\\whtvertoval",
    "⬰" => "\\circleonleftarrow",
    "⬱" => "\\leftthreearrows",
    "⬲" => "\\leftarrowonoplus",
    "⬳" => "\\longleftsquigarrow",
    "⬴" => "\\nvtwoheadleftarrow",
    "⬵" => "\\nVtwoheadleftarrow",
    "⬶" => "\\twoheadmapsfrom",
    "⬷" => "\\twoheadleftdbkarrow",
    "⬸" => "\\leftdotarrow",
    "⬹" => "\\nvleftarrowtail",
    "⬺" => "\\nVleftarrowtail",
    "⬻" => "\\twoheadleftarrowtail",
    "⬼" => "\\nvtwoheadleftarrowtail",
    "⬽" => "\\nVtwoheadleftarrowtail",
    "⬾" => "\\leftarrowx",
    "⬿" => "\\leftcurvedarrow",
    "⭀" => "\\equalleftarrow",
    "⭁" => "\\bsimilarleftarrow",
    "⭂" => "\\leftarrowbackapprox",
    "⭃" => "\\rightarrowgtr",
    "⭄" => "\\rightarrowsupset",
    "⭅" => "\\LLeftarrow",
    "⭆" => "\\RRightarrow",
    "⭇" => "\\bsimilarrightarrow",
    "⭈" => "\\rightarrowbackapprox",
    "⭉" => "\\similarleftarrow",
    "⭊" => "\\leftarrowapprox",
    "⭋" => "\\leftarrowbsimilar",
    "⭌" => "\\rightarrowbsimilar",
    "⭐" => "\\medwhitestar",
    "⭑" => "\\medblackstar",
    "⭒" => "\\smwhitestar",
    "⭓" => "\\rightpentagonblack",
    "⭔" => "\\rightpentagon",
    "ⱼ" => "\\_j",
    "ⱽ" => "\\^V",
    "〒" => "\\postalmark",
    "ꜛ" => "\\^uparrow",
    "ꜜ" => "\\^downarrow",
    "ꜝ" => "\\^!",
    "𝐀" => "\\bfA",
    "𝐁" => "\\bfB",
    "𝐂" => "\\bfC",
    "𝐃" => "\\bfD",
    "𝐄" => "\\bfE",
    "𝐅" => "\\bfF",
    "𝐆" => "\\bfG",
    "𝐇" => "\\bfH",
    "𝐈" => "\\bfI",
    "𝐉" => "\\bfJ",
    "𝐊" => "\\bfK",
    "𝐋" => "\\bfL",
    "𝐌" => "\\bfM",
    "𝐍" => "\\bfN",
    "𝐎" => "\\bfO",
    "𝐏" => "\\bfP",
    "𝐐" => "\\bfQ",
    "𝐑" => "\\bfR",
    "𝐒" => "\\bfS",
    "𝐓" => "\\bfT",
    "𝐔" => "\\bfU",
    "𝐕" => "\\bfV",
    "𝐖" => "\\bfW",
    "𝐗" => "\\bfX",
    "𝐘" => "\\bfY",
    "𝐙" => "\\bfZ",
    "𝐚" => "\\bfa",
    "𝐛" => "\\bfb",
    "𝐜" => "\\bfc",
    "𝐝" => "\\bfd",
    "𝐞" => "\\bfe",
    "𝐟" => "\\bff",
    "𝐠" => "\\bfg",
    "𝐡" => "\\bfh",
    "𝐢" => "\\bfi",
    "𝐣" => "\\bfj",
    "𝐤" => "\\bfk",
    "𝐥" => "\\bfl",
    "𝐦" => "\\bfm",
    "𝐧" => "\\bfn",
    "𝐨" => "\\bfo",
    "𝐩" => "\\bfp",
    "𝐪" => "\\bfq",
    "𝐫" => "\\bfr",
    "𝐬" => "\\bfs",
    "𝐭" => "\\bft",
    "𝐮" => "\\bfu",
    "𝐯" => "\\bfv",
    "𝐰" => "\\bfw",
    "𝐱" => "\\bfx",
    "𝐲" => "\\bfy",
    "𝐳" => "\\bfz",
    "𝐴" => "\\itA",
    "𝐵" => "\\itB",
    "𝐶" => "\\itC",
    "𝐷" => "\\itD",
    "𝐸" => "\\itE",
    "𝐹" => "\\itF",
    "𝐺" => "\\itG",
    "𝐻" => "\\itH",
    "𝐼" => "\\itI",
    "𝐽" => "\\itJ",
    "𝐾" => "\\itK",
    "𝐿" => "\\itL",
    "𝑀" => "\\itM",
    "𝑁" => "\\itN",
    "𝑂" => "\\itO",
    "𝑃" => "\\itP",
    "𝑄" => "\\itQ",
    "𝑅" => "\\itR",
    "𝑆" => "\\itS",
    "𝑇" => "\\itT",
    "𝑈" => "\\itU",
    "𝑉" => "\\itV",
    "𝑊" => "\\itW",
    "𝑋" => "\\itX",
    "𝑌" => "\\itY",
    "𝑍" => "\\itZ",
    "𝑎" => "\\ita",
    "𝑏" => "\\itb",
    "𝑐" => "\\itc",
    "𝑑" => "\\itd",
    "𝑒" => "\\ite",
    "𝑓" => "\\itf",
    "𝑔" => "\\itg",
    "𝑖" => "\\iti",
    "𝑗" => "\\itj",
    "𝑘" => "\\itk",
    "𝑙" => "\\itl",
    "𝑚" => "\\itm",
    "𝑛" => "\\itn",
    "𝑜" => "\\ito",
    "𝑝" => "\\itp",
    "𝑞" => "\\itq",
    "𝑟" => "\\itr",
    "𝑠" => "\\its",
    "𝑡" => "\\itt",
    "𝑢" => "\\itu",
    "𝑣" => "\\itv",
    "𝑤" => "\\itw",
    "𝑥" => "\\itx",
    "𝑦" => "\\ity",
    "𝑧" => "\\itz",
    "𝑨" => "\\biA",
    "𝑩" => "\\biB",
    "𝑪" => "\\biC",
    "𝑫" => "\\biD",
    "𝑬" => "\\biE",
    "𝑭" => "\\biF",
    "𝑮" => "\\biG",
    "𝑯" => "\\biH",
    "𝑰" => "\\biI",
    "𝑱" => "\\biJ",
    "𝑲" => "\\biK",
    "𝑳" => "\\biL",
    "𝑴" => "\\biM",
    "𝑵" => "\\biN",
    "𝑶" => "\\biO",
    "𝑷" => "\\biP",
    "𝑸" => "\\biQ",
    "𝑹" => "\\biR",
    "𝑺" => "\\biS",
    "𝑻" => "\\biT",
    "𝑼" => "\\biU",
    "𝑽" => "\\biV",
    "𝑾" => "\\biW",
    "𝑿" => "\\biX",
    "𝒀" => "\\biY",
    "𝒁" => "\\biZ",
    "𝒂" => "\\bia",
    "𝒃" => "\\bib",
    "𝒄" => "\\bic",
    "𝒅" => "\\bid",
    "𝒆" => "\\bie",
    "𝒇" => "\\bif",
    "𝒈" => "\\big",
    "𝒉" => "\\bih",
    "𝒊" => "\\bii",
    "𝒋" => "\\bij",
    "𝒌" => "\\bik",
    "𝒍" => "\\bil",
    "𝒎" => "\\bim",
    "𝒏" => "\\bin",
    "𝒐" => "\\bio",
    "𝒑" => "\\bip",
    "𝒒" => "\\biq",
    "𝒓" => "\\bir",
    "𝒔" => "\\bis",
    "𝒕" => "\\bit",
    "𝒖" => "\\biu",
    "𝒗" => "\\biv",
    "𝒘" => "\\biw",
    "𝒙" => "\\bix",
    "𝒚" => "\\biy",
    "𝒛" => "\\biz",
    "𝒜" => "\\scrA",
    "𝒞" => "\\scrC",
    "𝒟" => "\\scrD",
    "𝒢" => "\\scrG",
    "𝒥" => "\\scrJ",
    "𝒦" => "\\scrK",
    "𝒩" => "\\scrN",
    "𝒪" => "\\scrO",
    "𝒫" => "\\scrP",
    "𝒬" => "\\scrQ",
    "𝒮" => "\\scrS",
    "𝒯" => "\\scrT",
    "𝒰" => "\\scrU",
    "𝒱" => "\\scrV",
    "𝒲" => "\\scrW",
    "𝒳" => "\\scrX",
    "𝒴" => "\\scrY",
    "𝒵" => "\\scrZ",
    "𝒶" => "\\scra",
    "𝒷" => "\\scrb",
    "𝒸" => "\\scrc",
    "𝒹" => "\\scrd",
    "𝒻" => "\\scrf",
    "𝒽" => "\\scrh",
    "𝒾" => "\\scri",
    "𝒿" => "\\scrj",
    "𝓀" => "\\scrk",
    "𝓁" => "\\scrl",
    "𝓂" => "\\scrm",
    "𝓃" => "\\scrn",
    "𝓅" => "\\scrp",
    "𝓆" => "\\scrq",
    "𝓇" => "\\scrr",
    "𝓈" => "\\scrs",
    "𝓉" => "\\scrt",
    "𝓊" => "\\scru",
    "𝓋" => "\\scrv",
    "𝓌" => "\\scrw",
    "𝓍" => "\\scrx",
    "𝓎" => "\\scry",
    "𝓏" => "\\scrz",
    "𝓐" => "\\bscrA",
    "𝓑" => "\\bscrB",
    "𝓒" => "\\bscrC",
    "𝓓" => "\\bscrD",
    "𝓔" => "\\bscrE",
    "𝓕" => "\\bscrF",
    "𝓖" => "\\bscrG",
    "𝓗" => "\\bscrH",
    "𝓘" => "\\bscrI",
    "𝓙" => "\\bscrJ",
    "𝓚" => "\\bscrK",
    "𝓛" => "\\bscrL",
    "𝓜" => "\\bscrM",
    "𝓝" => "\\bscrN",
    "𝓞" => "\\bscrO",
    "𝓟" => "\\bscrP",
    "𝓠" => "\\bscrQ",
    "𝓡" => "\\bscrR",
    "𝓢" => "\\bscrS",
    "𝓣" => "\\bscrT",
    "𝓤" => "\\bscrU",
    "𝓥" => "\\bscrV",
    "𝓦" => "\\bscrW",
    "𝓧" => "\\bscrX",
    "𝓨" => "\\bscrY",
    "𝓩" => "\\bscrZ",
    "𝓪" => "\\bscra",
    "𝓫" => "\\bscrb",
    "𝓬" => "\\bscrc",
    "𝓭" => "\\bscrd",
    "𝓮" => "\\bscre",
    "𝓯" => "\\bscrf",
    "𝓰" => "\\bscrg",
    "𝓱" => "\\bscrh",
    "𝓲" => "\\bscri",
    "𝓳" => "\\bscrj",
    "𝓴" => "\\bscrk",
    "𝓵" => "\\bscrl",
    "𝓶" => "\\bscrm",
    "𝓷" => "\\bscrn",
    "𝓸" => "\\bscro",
    "𝓹" => "\\bscrp",
    "𝓺" => "\\bscrq",
    "𝓻" => "\\bscrr",
    "𝓼" => "\\bscrs",
    "𝓽" => "\\bscrt",
    "𝓾" => "\\bscru",
    "𝓿" => "\\bscrv",
    "𝔀" => "\\bscrw",
    "𝔁" => "\\bscrx",
    "𝔂" => "\\bscry",
    "𝔃" => "\\bscrz",
    "𝔄" => "\\frakA",
    "𝔅" => "\\frakB",
    "𝔇" => "\\frakD",
    "𝔈" => "\\frakE",
    "𝔉" => "\\frakF",
    "𝔊" => "\\frakG",
    "𝔍" => "\\frakJ",
    "𝔎" => "\\frakK",
    "𝔏" => "\\frakL",
    "𝔐" => "\\frakM",
    "𝔑" => "\\frakN",
    "𝔒" => "\\frakO",
    "𝔓" => "\\frakP",
    "𝔔" => "\\frakQ",
    "𝔖" => "\\frakS",
    "𝔗" => "\\frakT",
    "𝔘" => "\\frakU",
    "𝔙" => "\\frakV",
    "𝔚" => "\\frakW",
    "𝔛" => "\\frakX",
    "𝔜" => "\\frakY",
    "𝔞" => "\\fraka",
    "𝔟" => "\\frakb",
    "𝔠" => "\\frakc",
    "𝔡" => "\\frakd",
    "𝔢" => "\\frake",
    "𝔣" => "\\frakf",
    "𝔤" => "\\frakg",
    "𝔥" => "\\frakh",
    "𝔦" => "\\fraki",
    "𝔧" => "\\frakj",
    "𝔨" => "\\frakk",
    "𝔩" => "\\frakl",
    "𝔪" => "\\frakm",
    "𝔫" => "\\frakn",
    "𝔬" => "\\frako",
    "𝔭" => "\\frakp",
    "𝔮" => "\\frakq",
    "𝔯" => "\\frakr",
    "𝔰" => "\\fraks",
    "𝔱" => "\\frakt",
    "𝔲" => "\\fraku",
    "𝔳" => "\\frakv",
    "𝔴" => "\\frakw",
    "𝔵" => "\\frakx",
    "𝔶" => "\\fraky",
    "𝔷" => "\\frakz",
    "𝔸" => "\\bbA",
    "𝔹" => "\\bbB",
    "𝔻" => "\\bbD",
    "𝔼" => "\\bbE",
    "𝔽" => "\\bbF",
    "𝔾" => "\\bbG",
    "𝕀" => "\\bbI",
    "𝕁" => "\\bbJ",
    "𝕂" => "\\bbK",
    "𝕃" => "\\bbL",
    "𝕄" => "\\bbM",
    "𝕆" => "\\bbO",
    "𝕊" => "\\bbS",
    "𝕋" => "\\bbT",
    "𝕌" => "\\bbU",
    "𝕍" => "\\bbV",
    "𝕎" => "\\bbW",
    "𝕏" => "\\bbX",
    "𝕐" => "\\bbY",
    "𝕒" => "\\bba",
    "𝕓" => "\\bbb",
    "𝕔" => "\\bbc",
    "𝕕" => "\\bbd",
    "𝕖" => "\\bbe",
    "𝕗" => "\\bbf",
    "𝕘" => "\\bbg",
    "𝕙" => "\\bbh",
    "𝕚" => "\\bbi",
    "𝕛" => "\\bbj",
    "𝕜" => "\\bbk",
    "𝕝" => "\\bbl",
    "𝕞" => "\\bbm",
    "𝕟" => "\\bbn",
    "𝕠" => "\\bbo",
    "𝕡" => "\\bbp",
    "𝕢" => "\\bbq",
    "𝕣" => "\\bbr",
    "𝕤" => "\\bbs",
    "𝕥" => "\\bbt",
    "𝕦" => "\\bbu",
    "𝕧" => "\\bbv",
    "𝕨" => "\\bbw",
    "𝕩" => "\\bbx",
    "𝕪" => "\\bby",
    "𝕫" => "\\bbz",
    "𝕬" => "\\bfrakA",
    "𝕭" => "\\bfrakB",
    "𝕮" => "\\bfrakC",
    "𝕯" => "\\bfrakD",
    "𝕰" => "\\bfrakE",
    "𝕱" => "\\bfrakF",
    "𝕲" => "\\bfrakG",
    "𝕳" => "\\bfrakH",
    "𝕴" => "\\bfrakI",
    "𝕵" => "\\bfrakJ",
    "𝕶" => "\\bfrakK",
    "𝕷" => "\\bfrakL",
    "𝕸" => "\\bfrakM",
    "𝕹" => "\\bfrakN",
    "𝕺" => "\\bfrakO",
    "𝕻" => "\\bfrakP",
    "𝕼" => "\\bfrakQ",
    "𝕽" => "\\bfrakR",
    "𝕾" => "\\bfrakS",
    "𝕿" => "\\bfrakT",
    "𝖀" => "\\bfrakU",
    "𝖁" => "\\bfrakV",
    "𝖂" => "\\bfrakW",
    "𝖃" => "\\bfrakX",
    "𝖄" => "\\bfrakY",
    "𝖅" => "\\bfrakZ",
    "𝖆" => "\\bfraka",
    "𝖇" => "\\bfrakb",
    "𝖈" => "\\bfrakc",
    "𝖉" => "\\bfrakd",
    "𝖊" => "\\bfrake",
    "𝖋" => "\\bfrakf",
    "𝖌" => "\\bfrakg",
    "𝖍" => "\\bfrakh",
    "𝖎" => "\\bfraki",
    "𝖏" => "\\bfrakj",
    "𝖐" => "\\bfrakk",
    "𝖑" => "\\bfrakl",
    "𝖒" => "\\bfrakm",
    "𝖓" => "\\bfrakn",
    "𝖔" => "\\bfrako",
    "𝖕" => "\\bfrakp",
    "𝖖" => "\\bfrakq",
    "𝖗" => "\\bfrakr",
    "𝖘" => "\\bfraks",
    "𝖙" => "\\bfrakt",
    "𝖚" => "\\bfraku",
    "𝖛" => "\\bfrakv",
    "𝖜" => "\\bfrakw",
    "𝖝" => "\\bfrakx",
    "𝖞" => "\\bfraky",
    "𝖟" => "\\bfrakz",
    "𝖠" => "\\sansA",
    "𝖡" => "\\sansB",
    "𝖢" => "\\sansC",
    "𝖣" => "\\sansD",
    "𝖤" => "\\sansE",
    "𝖥" => "\\sansF",
    "𝖦" => "\\sansG",
    "𝖧" => "\\sansH",
    "𝖨" => "\\sansI",
    "𝖩" => "\\sansJ",
    "𝖪" => "\\sansK",
    "𝖫" => "\\sansL",
    "𝖬" => "\\sansM",
    "𝖭" => "\\sansN",
    "𝖮" => "\\sansO",
    "𝖯" => "\\sansP",
    "𝖰" => "\\sansQ",
    "𝖱" => "\\sansR",
    "𝖲" => "\\sansS",
    "𝖳" => "\\sansT",
    "𝖴" => "\\sansU",
    "𝖵" => "\\sansV",
    "𝖶" => "\\sansW",
    "𝖷" => "\\sansX",
    "𝖸" => "\\sansY",
    "𝖹" => "\\sansZ",
    "𝖺" => "\\sansa",
    "𝖻" => "\\sansb",
    "𝖼" => "\\sansc",
    "𝖽" => "\\sansd",
    "𝖾" => "\\sanse",
    "𝖿" => "\\sansf",
    "𝗀" => "\\sansg",
    "𝗁" => "\\sansh",
    "𝗂" => "\\sansi",
    "𝗃" => "\\sansj",
    "𝗄" => "\\sansk",
    "𝗅" => "\\sansl",
    "𝗆" => "\\sansm",
    "𝗇" => "\\sansn",
    "𝗈" => "\\sanso",
    "𝗉" => "\\sansp",
    "𝗊" => "\\sansq",
    "𝗋" => "\\sansr",
    "𝗌" => "\\sanss",
    "𝗍" => "\\sanst",
    "𝗎" => "\\sansu",
    "𝗏" => "\\sansv",
    "𝗐" => "\\sansw",
    "𝗑" => "\\sansx",
    "𝗒" => "\\sansy",
    "𝗓" => "\\sansz",
    "𝗔" => "\\bsansA",
    "𝗕" => "\\bsansB",
    "𝗖" => "\\bsansC",
    "𝗗" => "\\bsansD",
    "𝗘" => "\\bsansE",
    "𝗙" => "\\bsansF",
    "𝗚" => "\\bsansG",
    "𝗛" => "\\bsansH",
    "𝗜" => "\\bsansI",
    "𝗝" => "\\bsansJ",
    "𝗞" => "\\bsansK",
    "𝗟" => "\\bsansL",
    "𝗠" => "\\bsansM",
    "𝗡" => "\\bsansN",
    "𝗢" => "\\bsansO",
    "𝗣" => "\\bsansP",
    "𝗤" => "\\bsansQ",
    "𝗥" => "\\bsansR",
    "𝗦" => "\\bsansS",
    "𝗧" => "\\bsansT",
    "𝗨" => "\\bsansU",
    "𝗩" => "\\bsansV",
    "𝗪" => "\\bsansW",
    "𝗫" => "\\bsansX",
    "𝗬" => "\\bsansY",
    "𝗭" => "\\bsansZ",
    "𝗮" => "\\bsansa",
    "𝗯" => "\\bsansb",
    "𝗰" => "\\bsansc",
    "𝗱" => "\\bsansd",
    "𝗲" => "\\bsanse",
    "𝗳" => "\\bsansf",
    "𝗴" => "\\bsansg",
    "𝗵" => "\\bsansh",
    "𝗶" => "\\bsansi",
    "𝗷" => "\\bsansj",
    "𝗸" => "\\bsansk",
    "𝗹" => "\\bsansl",
    "𝗺" => "\\bsansm",
    "𝗻" => "\\bsansn",
    "𝗼" => "\\bsanso",
    "𝗽" => "\\bsansp",
    "𝗾" => "\\bsansq",
    "𝗿" => "\\bsansr",
    "𝘀" => "\\bsanss",
    "𝘁" => "\\bsanst",
    "𝘂" => "\\bsansu",
    "𝘃" => "\\bsansv",
    "𝘄" => "\\bsansw",
    "𝘅" => "\\bsansx",
    "𝘆" => "\\bsansy",
    "𝘇" => "\\bsansz",
    "𝘈" => "\\isansA",
    "𝘉" => "\\isansB",
    "𝘊" => "\\isansC",
    "𝘋" => "\\isansD",
    "𝘌" => "\\isansE",
    "𝘍" => "\\isansF",
    "𝘎" => "\\isansG",
    "𝘏" => "\\isansH",
    "𝘐" => "\\isansI",
    "𝘑" => "\\isansJ",
    "𝘒" => "\\isansK",
    "𝘓" => "\\isansL",
    "𝘔" => "\\isansM",
    "𝘕" => "\\isansN",
    "𝘖" => "\\isansO",
    "𝘗" => "\\isansP",
    "𝘘" => "\\isansQ",
    "𝘙" => "\\isansR",
    "𝘚" => "\\isansS",
    "𝘛" => "\\isansT",
    "𝘜" => "\\isansU",
    "𝘝" => "\\isansV",
    "𝘞" => "\\isansW",
    "𝘟" => "\\isansX",
    "𝘠" => "\\isansY",
    "𝘡" => "\\isansZ",
    "𝘢" => "\\isansa",
    "𝘣" => "\\isansb",
    "𝘤" => "\\isansc",
    "𝘥" => "\\isansd",
    "𝘦" => "\\isanse",
    "𝘧" => "\\isansf",
    "𝘨" => "\\isansg",
    "𝘩" => "\\isansh",
    "𝘪" => "\\isansi",
    "𝘫" => "\\isansj",
    "𝘬" => "\\isansk",
    "𝘭" => "\\isansl",
    "𝘮" => "\\isansm",
    "𝘯" => "\\isansn",
    "𝘰" => "\\isanso",
    "𝘱" => "\\isansp",
    "𝘲" => "\\isansq",
    "𝘳" => "\\isansr",
    "𝘴" => "\\isanss",
    "𝘵" => "\\isanst",
    "𝘶" => "\\isansu",
    "𝘷" => "\\isansv",
    "𝘸" => "\\isansw",
    "𝘹" => "\\isansx",
    "𝘺" => "\\isansy",
    "𝘻" => "\\isansz",
    "𝘼" => "\\bisansA",
    "𝘽" => "\\bisansB",
    "𝘾" => "\\bisansC",
    "𝘿" => "\\bisansD",
    "𝙀" => "\\bisansE",
    "𝙁" => "\\bisansF",
    "𝙂" => "\\bisansG",
    "𝙃" => "\\bisansH",
    "𝙄" => "\\bisansI",
    "𝙅" => "\\bisansJ",
    "𝙆" => "\\bisansK",
    "𝙇" => "\\bisansL",
    "𝙈" => "\\bisansM",
    "𝙉" => "\\bisansN",
    "𝙊" => "\\bisansO",
    "𝙋" => "\\bisansP",
    "𝙌" => "\\bisansQ",
    "𝙍" => "\\bisansR",
    "𝙎" => "\\bisansS",
    "𝙏" => "\\bisansT",
    "𝙐" => "\\bisansU",
    "𝙑" => "\\bisansV",
    "𝙒" => "\\bisansW",
    "𝙓" => "\\bisansX",
    "𝙔" => "\\bisansY",
    "𝙕" => "\\bisansZ",
    "𝙖" => "\\bisansa",
    "𝙗" => "\\bisansb",
    "𝙘" => "\\bisansc",
    "𝙙" => "\\bisansd",
    "𝙚" => "\\bisanse",
    "𝙛" => "\\bisansf",
    "𝙜" => "\\bisansg",
    "𝙝" => "\\bisansh",
    "𝙞" => "\\bisansi",
    "𝙟" => "\\bisansj",
    "𝙠" => "\\bisansk",
    "𝙡" => "\\bisansl",
    "𝙢" => "\\bisansm",
    "𝙣" => "\\bisansn",
    "𝙤" => "\\bisanso",
    "𝙥" => "\\bisansp",
    "𝙦" => "\\bisansq",
    "𝙧" => "\\bisansr",
    "𝙨" => "\\bisanss",
    "𝙩" => "\\bisanst",
    "𝙪" => "\\bisansu",
    "𝙫" => "\\bisansv",
    "𝙬" => "\\bisansw",
    "𝙭" => "\\bisansx",
    "𝙮" => "\\bisansy",
    "𝙯" => "\\bisansz",
    "𝙰" => "\\ttA",
    "𝙱" => "\\ttB",
    "𝙲" => "\\ttC",
    "𝙳" => "\\ttD",
    "𝙴" => "\\ttE",
    "𝙵" => "\\ttF",
    "𝙶" => "\\ttG",
    "𝙷" => "\\ttH",
    "𝙸" => "\\ttI",
    "𝙹" => "\\ttJ",
    "𝙺" => "\\ttK",
    "𝙻" => "\\ttL",
    "𝙼" => "\\ttM",
    "𝙽" => "\\ttN",
    "𝙾" => "\\ttO",
    "𝙿" => "\\ttP",
    "𝚀" => "\\ttQ",
    "𝚁" => "\\ttR",
    "𝚂" => "\\ttS",
    "𝚃" => "\\ttT",
    "𝚄" => "\\ttU",
    "𝚅" => "\\ttV",
    "𝚆" => "\\ttW",
    "𝚇" => "\\ttX",
    "𝚈" => "\\ttY",
    "𝚉" => "\\ttZ",
    "𝚊" => "\\tta",
    "𝚋" => "\\ttb",
    "𝚌" => "\\ttc",
    "𝚍" => "\\ttd",
    "𝚎" => "\\tte",
    "𝚏" => "\\ttf",
    "𝚐" => "\\ttg",
    "𝚑" => "\\tth",
    "𝚒" => "\\tti",
    "𝚓" => "\\ttj",
    "𝚔" => "\\ttk",
    "𝚕" => "\\ttl",
    "𝚖" => "\\ttm",
    "𝚗" => "\\ttn",
    "𝚘" => "\\tto",
    "𝚙" => "\\ttp",
    "𝚚" => "\\ttq",
    "𝚛" => "\\ttr",
    "𝚜" => "\\tts",
    "𝚝" => "\\ttt",
    "𝚞" => "\\ttu",
    "𝚟" => "\\ttv",
    "𝚠" => "\\ttw",
    "𝚡" => "\\ttx",
    "𝚢" => "\\tty",
    "𝚣" => "\\ttz",
    "𝚤" => "\\itimath",
    "𝚥" => "\\itjmath",
    "𝚨" => "\\bfAlpha",
    "𝚩" => "\\bfBeta",
    "𝚪" => "\\bfGamma",
    "𝚫" => "\\bfDelta",
    "𝚬" => "\\bfEpsilon",
    "𝚭" => "\\bfZeta",
    "𝚮" => "\\bfEta",
    "𝚯" => "\\bfTheta",
    "𝚰" => "\\bfIota",
    "𝚱" => "\\bfKappa",
    "𝚲" => "\\bfLambda",
    "𝚳" => "\\bfMu",
    "𝚴" => "\\bfNu",
    "𝚵" => "\\bfXi",
    "𝚶" => "\\bfOmicron",
    "𝚷" => "\\bfPi",
    "𝚸" => "\\bfRho",
    "𝚹" => "\\bfvarTheta",
    "𝚺" => "\\bfSigma",
    "𝚻" => "\\bfTau",
    "𝚼" => "\\bfUpsilon",
    "𝚽" => "\\bfPhi",
    "𝚾" => "\\bfChi",
    "𝚿" => "\\bfPsi",
    "𝛀" => "\\bfOmega",
    "𝛁" => "\\bfnabla",
    "𝛂" => "\\bfalpha",
    "𝛃" => "\\bfbeta",
    "𝛄" => "\\bfgamma",
    "𝛅" => "\\bfdelta",
    "𝛆" => "\\bfepsilon",
    "𝛇" => "\\bfzeta",
    "𝛈" => "\\bfeta",
    "𝛉" => "\\bftheta",
    "𝛊" => "\\bfiota",
    "𝛋" => "\\bfkappa",
    "𝛌" => "\\bflambda",
    "𝛍" => "\\bfmu",
    "𝛎" => "\\bfnu",
    "𝛏" => "\\bfxi",
    "𝛐" => "\\bfomicron",
    "𝛑" => "\\bfpi",
    "𝛒" => "\\bfrho",
    "𝛓" => "\\bfvarsigma",
    "𝛔" => "\\bfsigma",
    "𝛕" => "\\bftau",
    "𝛖" => "\\bfupsilon",
    "𝛗" => "\\bfvarphi",
    "𝛘" => "\\bfchi",
    "𝛙" => "\\bfpsi",
    "𝛚" => "\\bfomega",
    "𝛛" => "\\bfpartial",
    "𝛜" => "\\bfvarepsilon",
    "𝛝" => "\\bfvartheta",
    "𝛞" => "\\bfvarkappa",
    "𝛟" => "\\bfphi",
    "𝛠" => "\\bfvarrho",
    "𝛡" => "\\bfvarpi",
    "𝛢" => "\\itAlpha",
    "𝛣" => "\\itBeta",
    "𝛤" => "\\itGamma",
    "𝛥" => "\\itDelta",
    "𝛦" => "\\itEpsilon",
    "𝛧" => "\\itZeta",
    "𝛨" => "\\itEta",
    "𝛩" => "\\itTheta",
    "𝛪" => "\\itIota",
    "𝛫" => "\\itKappa",
    "𝛬" => "\\itLambda",
    "𝛭" => "\\itMu",
    "𝛮" => "\\itNu",
    "𝛯" => "\\itXi",
    "𝛰" => "\\itOmicron",
    "𝛱" => "\\itPi",
    "𝛲" => "\\itRho",
    "𝛳" => "\\itvarTheta",
    "𝛴" => "\\itSigma",
    "𝛵" => "\\itTau",
    "𝛶" => "\\itUpsilon",
    "𝛷" => "\\itPhi",
    "𝛸" => "\\itChi",
    "𝛹" => "\\itPsi",
    "𝛺" => "\\itOmega",
    "𝛻" => "\\itnabla",
    "𝛼" => "\\italpha",
    "𝛽" => "\\itbeta",
    "𝛾" => "\\itgamma",
    "𝛿" => "\\itdelta",
    "𝜀" => "\\itepsilon",
    "𝜁" => "\\itzeta",
    "𝜂" => "\\iteta",
    "𝜃" => "\\ittheta",
    "𝜄" => "\\itiota",
    "𝜅" => "\\itkappa",
    "𝜆" => "\\itlambda",
    "𝜇" => "\\itmu",
    "𝜈" => "\\itnu",
    "𝜉" => "\\itxi",
    "𝜊" => "\\itomicron",
    "𝜋" => "\\itpi",
    "𝜌" => "\\itrho",
    "𝜍" => "\\itvarsigma",
    "𝜎" => "\\itsigma",
    "𝜏" => "\\ittau",
    "𝜐" => "\\itupsilon",
    "𝜑" => "\\itphi",
    "𝜒" => "\\itchi",
    "𝜓" => "\\itpsi",
    "𝜔" => "\\itomega",
    "𝜕" => "\\itpartial",
    "𝜖" => "\\itvarepsilon",
    "𝜗" => "\\itvartheta",
    "𝜘" => "\\itvarkappa",
    "𝜙" => "\\itvarphi",
    "𝜚" => "\\itvarrho",
    "𝜛" => "\\itvarpi",
    "𝜜" => "\\biAlpha",
    "𝜝" => "\\biBeta",
    "𝜞" => "\\biGamma",
    "𝜟" => "\\biDelta",
    "𝜠" => "\\biEpsilon",
    "𝜡" => "\\biZeta",
    "𝜢" => "\\biEta",
    "𝜣" => "\\biTheta",
    "𝜤" => "\\biIota",
    "𝜥" => "\\biKappa",
    "𝜦" => "\\biLambda",
    "𝜧" => "\\biMu",
    "𝜨" => "\\biNu",
    "𝜩" => "\\biXi",
    "𝜪" => "\\biOmicron",
    "𝜫" => "\\biPi",
    "𝜬" => "\\biRho",
    "𝜭" => "\\bivarTheta",
    "𝜮" => "\\biSigma",
    "𝜯" => "\\biTau",
    "𝜰" => "\\biUpsilon",
    "𝜱" => "\\biPhi",
    "𝜲" => "\\biChi",
    "𝜳" => "\\biPsi",
    "𝜴" => "\\biOmega",
    "𝜵" => "\\binabla",
    "𝜶" => "\\bialpha",
    "𝜷" => "\\bibeta",
    "𝜸" => "\\bigamma",
    "𝜹" => "\\bidelta",
    "𝜺" => "\\biepsilon",
    "𝜻" => "\\bizeta",
    "𝜼" => "\\bieta",
    "𝜽" => "\\bitheta",
    "𝜾" => "\\biiota",
    "𝜿" => "\\bikappa",
    "𝝀" => "\\bilambda",
    "𝝁" => "\\bimu",
    "𝝂" => "\\binu",
    "𝝃" => "\\bixi",
    "𝝄" => "\\biomicron",
    "𝝅" => "\\bipi",
    "𝝆" => "\\birho",
    "𝝇" => "\\bivarsigma",
    "𝝈" => "\\bisigma",
    "𝝉" => "\\bitau",
    "𝝊" => "\\biupsilon",
    "𝝋" => "\\biphi",
    "𝝌" => "\\bichi",
    "𝝍" => "\\bipsi",
    "𝝎" => "\\biomega",
    "𝝏" => "\\bipartial",
    "𝝐" => "\\bivarepsilon",
    "𝝑" => "\\bivartheta",
    "𝝒" => "\\bivarkappa",
    "𝝓" => "\\bivarphi",
    "𝝔" => "\\bivarrho",
    "𝝕" => "\\bivarpi",
    "𝝖" => "\\bsansAlpha",
    "𝝗" => "\\bsansBeta",
    "𝝘" => "\\bsansGamma",
    "𝝙" => "\\bsansDelta",
    "𝝚" => "\\bsansEpsilon",
    "𝝛" => "\\bsansZeta",
    "𝝜" => "\\bsansEta",
    "𝝝" => "\\bsansTheta",
    "𝝞" => "\\bsansIota",
    "𝝟" => "\\bsansKappa",
    "𝝠" => "\\bsansLambda",
    "𝝡" => "\\bsansMu",
    "𝝢" => "\\bsansNu",
    "𝝣" => "\\bsansXi",
    "𝝤" => "\\bsansOmicron",
    "𝝥" => "\\bsansPi",
    "𝝦" => "\\bsansRho",
    "𝝧" => "\\bsansvarTheta",
    "𝝨" => "\\bsansSigma",
    "𝝩" => "\\bsansTau",
    "𝝪" => "\\bsansUpsilon",
    "𝝫" => "\\bsansPhi",
    "𝝬" => "\\bsansChi",
    "𝝭" => "\\bsansPsi",
    "𝝮" => "\\bsansOmega",
    "𝝯" => "\\bsansnabla",
    "𝝰" => "\\bsansalpha",
    "𝝱" => "\\bsansbeta",
    "𝝲" => "\\bsansgamma",
    "𝝳" => "\\bsansdelta",
    "𝝴" => "\\bsansepsilon",
    "𝝵" => "\\bsanszeta",
    "𝝶" => "\\bsanseta",
    "𝝷" => "\\bsanstheta",
    "𝝸" => "\\bsansiota",
    "𝝹" => "\\bsanskappa",
    "𝝺" => "\\bsanslambda",
    "𝝻" => "\\bsansmu",
    "𝝼" => "\\bsansnu",
    "𝝽" => "\\bsansxi",
    "𝝾" => "\\bsansomicron",
    "𝝿" => "\\bsanspi",
    "𝞀" => "\\bsansrho",
    "𝞁" => "\\bsansvarsigma",
    "𝞂" => "\\bsanssigma",
    "𝞃" => "\\bsanstau",
    "𝞄" => "\\bsansupsilon",
    "𝞅" => "\\bsansphi",
    "𝞆" => "\\bsanschi",
    "𝞇" => "\\bsanspsi",
    "𝞈" => "\\bsansomega",
    "𝞉" => "\\bsanspartial",
    "𝞊" => "\\bsansvarepsilon",
    "𝞋" => "\\bsansvartheta",
    "𝞌" => "\\bsansvarkappa",
    "𝞍" => "\\bsansvarphi",
    "𝞎" => "\\bsansvarrho",
    "𝞏" => "\\bsansvarpi",
    "𝞐" => "\\bisansAlpha",
    "𝞑" => "\\bisansBeta",
    "𝞒" => "\\bisansGamma",
    "𝞓" => "\\bisansDelta",
    "𝞔" => "\\bisansEpsilon",
    "𝞕" => "\\bisansZeta",
    "𝞖" => "\\bisansEta",
    "𝞗" => "\\bisansTheta",
    "𝞘" => "\\bisansIota",
    "𝞙" => "\\bisansKappa",
    "𝞚" => "\\bisansLambda",
    "𝞛" => "\\bisansMu",
    "𝞜" => "\\bisansNu",
    "𝞝" => "\\bisansXi",
    "𝞞" => "\\bisansOmicron",
    "𝞟" => "\\bisansPi",
    "𝞠" => "\\bisansRho",
    "𝞡" => "\\bisansvarTheta",
    "𝞢" => "\\bisansSigma",
    "𝞣" => "\\bisansTau",
    "𝞤" => "\\bisansUpsilon",
    "𝞥" => "\\bisansPhi",
    "𝞦" => "\\bisansChi",
    "𝞧" => "\\bisansPsi",
    "𝞨" => "\\bisansOmega",
    "𝞩" => "\\bisansnabla",
    "𝞪" => "\\bisansalpha",
    "𝞫" => "\\bisansbeta",
    "𝞬" => "\\bisansgamma",
    "𝞭" => "\\bisansdelta",
    "𝞮" => "\\bisansepsilon",
    "𝞯" => "\\bisanszeta",
    "𝞰" => "\\bisanseta",
    "𝞱" => "\\bisanstheta",
    "𝞲" => "\\bisansiota",
    "𝞳" => "\\bisanskappa",
    "𝞴" => "\\bisanslambda",
    "𝞵" => "\\bisansmu",
    "𝞶" => "\\bisansnu",
    "𝞷" => "\\bisansxi",
    "𝞸" => "\\bisansomicron",
    "𝞹" => "\\bisanspi",
    "𝞺" => "\\bisansrho",
    "𝞻" => "\\bisansvarsigma",
    "𝞼" => "\\bisanssigma",
    "𝞽" => "\\bisanstau",
    "𝞾" => "\\bisansupsilon",
    "𝞿" => "\\bisansphi",
    "𝟀" => "\\bisanschi",
    "𝟁" => "\\bisanspsi",
    "𝟂" => "\\bisansomega",
    "𝟃" => "\\bisanspartial",
    "𝟄" => "\\bisansvarepsilon",
    "𝟅" => "\\bisansvartheta",
    "𝟆" => "\\bisansvarkappa",
    "𝟇" => "\\bisansvarphi",
    "𝟈" => "\\bisansvarrho",
    "𝟉" => "\\bisansvarpi",
    "𝟊" => "\\bfDigamma",
    "𝟋" => "\\bfdigamma",
    "𝟎" => "\\bfzero",
    "𝟏" => "\\bfone",
    "𝟐" => "\\bftwo",
    "𝟑" => "\\bfthree",
    "𝟒" => "\\bffour",
    "𝟓" => "\\bffive",
    "𝟔" => "\\bfsix",
    "𝟕" => "\\bfseven",
    "𝟖" => "\\bfeight",
    "𝟗" => "\\bfnine",
    "𝟘" => "\\bbzero",
    "𝟙" => "\\bbone",
    "𝟚" => "\\bbtwo",
    "𝟛" => "\\bbthree",
    "𝟜" => "\\bbfour",
    "𝟝" => "\\bbfive",
    "𝟞" => "\\bbsix",
    "𝟟" => "\\bbseven",
    "𝟠" => "\\bbeight",
    "𝟡" => "\\bbnine",
    "𝟢" => "\\sanszero",
    "𝟣" => "\\sansone",
    "𝟤" => "\\sanstwo",
    "𝟥" => "\\sansthree",
    "𝟦" => "\\sansfour",
    "𝟧" => "\\sansfive",
    "𝟨" => "\\sanssix",
    "𝟩" => "\\sansseven",
    "𝟪" => "\\sanseight",
    "𝟫" => "\\sansnine",
    "𝟬" => "\\bsanszero",
    "𝟭" => "\\bsansone",
    "𝟮" => "\\bsanstwo",
    "𝟯" => "\\bsansthree",
    "𝟰" => "\\bsansfour",
    "𝟱" => "\\bsansfive",
    "𝟲" => "\\bsanssix",
    "𝟳" => "\\bsansseven",
    "𝟴" => "\\bsanseight",
    "𝟵" => "\\bsansnine",
    "𝟶" => "\\ttzero",
    "𝟷" => "\\ttone",
    "𝟸" => "\\tttwo",
    "𝟹" => "\\ttthree",
    "𝟺" => "\\ttfour",
    "𝟻" => "\\ttfive",
    "𝟼" => "\\ttsix",
    "𝟽" => "\\ttseven",
    "𝟾" => "\\tteight",
    "𝟿" => "\\ttnine",
)


text:
# Euclidean Manifold definitions and arithmetic

get2DLambda(Lambdas::AbstractVector{<:Real}) = sum(Lambdas)

#

ext: jl


text:
```
ДАНО: Робот находится в произвольной клетке ограниченного прямоугольного поля c внутреннеми перегородоками.
РЕЗУЛЬТАТ: Робот — в исходном положении в центре прямого креста из маркеров, расставленных вплоть до внешней рамки.
Рассмотреть отдельно еще случай, когда изначально в некоторых клетках поля могут находиться маркеры.
```

```
Если на поле будут стоять маркеры, то они не повлияют на ход программы. Иначе можно было бы добавить проверку
на наличие маркера в клетке, стоящей на пути Робота.

```

using HorizonSideRobots
originRobot = Robot(animate = true, "14example.sit")
include("../AbstractType.jl")
include("../functions.jl")

function master!(robot::Beta)
    for side in [Nord, Ost, Sud, West]
        while (try_move!(robot, side))
            putmarker!(robot.beta)
        end
        putmarker!(robot.beta)
        get_back!(robot)
    end
    putmarker!(robot.beta)
end

master!(beta)

max_stars_repo_name: Igetsuga/AlgorithmicsHomework

max_issues_repo_name: Igetsuga/AlgorithmicsHomework

max_forks_repo_name: Igetsuga/AlgorithmicsHomework


text:
module TestExamples3DCurved

using Test
using Trixi

include("test_trixi.jl")

# pathof(Trixi) returns /path/to/Trixi/src/Trixi.jl, dirname gives the parent directory
EXAMPLES_DIR = joinpath(pathof(Trixi) |> dirname |> dirname, "examples", "3d")

@testset "Curved mesh" begin
  @testset "elixir_advection_basic_curved.jl" begin
    @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_advection_basic_curved.jl"),
      l2   = [0.00013446460962856976],
      linf = [0.0012577781391462928])
  end

  @testset "elixir_advection_free_stream_curved.jl" begin
    @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_advection_free_stream_curved.jl"),
      l2   = [1.830875777528287e-14],
      linf = [7.491784970170556e-13],
      atol = 8e-13, # required to make tests pass on Windows
      )
  end

  @testset "elixir_euler_source_terms_curved.jl" begin
    @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_source_terms_curved.jl"),
      l2   = [0.01032310150257373, 0.009728768969448439, 0.009728768969448494, 0.009728768969448388, 0.015080412597559597],
      linf = [0.034894790428615874, 0.033835365548322116, 0.033835365548322116, 0.03383536554832034, 0.06785765131417065])
  end

  @testset "elixir_euler_free_stream_curved.jl" begin
    @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_free_stream_curved.jl"),
      l2   = [2.8815700334367128e-15, 9.361915278236651e-15, 9.95614203619935e-15, 1.6809941842374106e-14, 1.4815037041566735e-14],
      linf = [4.1300296516055823e-14, 2.0444756998472258e-13, 1.0133560657266116e-13, 3.1896707497480747e-13, 6.092903959142859e-13])
  end
end

end # module


text:
module MCToy

# package code goes here
include("core.jl")

end # module


text:
# This file is a part of JuliaFEM.
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md

using JuliaFEM
using JuliaFEM.Preprocess
using JuliaFEM.Postprocess
using JuliaFEM.Testing

function JuliaFEM.get_mesh(::Type{Val{Symbol("curved 2d block splitted to upper and lower")}})
    meshfile = Pkg.dir("JuliaFEM") * "/test/testdata/block_2d_curved.med"
    mesh = aster_read_mesh(meshfile)
end

function JuliaFEM.get_model(::Type{Val{Symbol("mesh tie with curved 2d block")}};
            dy=0.0, adjust=false, tolerance=0.0, rotate_normals=false, swap=false,
            dual_basis=false, use_forwarddiff=true, finite_strain=false,
            geometric_stiffness=false)

    mesh = get_mesh("curved 2d block splitted to upper and lower")

    upper = Problem(Elasticity, "upper", 2)
    upper.properties.formulation = :plane_stress
    upper.properties.finite_strain = finite_strain
    upper.properties.geometric_stiffness = geometric_stiffness
    upper.elements = create_elements(mesh, "UPPER")
    update!(upper.elements, "youngs modulus", 96.0)
    update!(upper.elements, "poissons ratio", 1/3)

    lower = Problem(Elasticity, "lower", 2)
    lower.properties.formulation = :plane_stress
    lower.properties.finite_strain = finite_strain
    lower.properties.geometric_stiffness = geometric_stiffness
    lower.elements = create_elements(mesh, "LOWER")
    update!(lower.elements, "youngs modulus", 96.0)
    update!(lower.elements, "poissons ratio", 1/3)

    bc_upper = Problem(Dirichlet, "upper boundary", 2, "displacement")
    bc_upper.elements = create_elements(mesh, "UPPER_TOP")
    update!(bc_upper.elements, "displacement 1", 0.0)
    update!(bc_upper.elements, "displacement 2", dy)

    bc_lower = Problem(Dirichlet, "lower boundary", 2, "displacement")
    bc_lower.elements = create_elements(mesh, "LOWER_BOTTOM")
    update!(bc_lower.elements, "displacement 1", 0.0)
    update!(bc_lower.elements, "displacement 2", 0.0)

    interface = Problem(Mortar, "interface between upper and lower block", 2, "displacement")
    interface_slave_elements = create_elements(mesh, "LOWER_TOP")
    interface_master_elements = create_elements(mesh, "UPPER_BOTTOM")
    if swap
        interface_slave_elements, interface_master_elements = interface_master_elements, interface_slave_elements
    end
    update!(interface_slave_elements, "master elements", interface_master_elements)
    interface.elements = [interface_master_elements; interface_slave_elements]
    interface.properties.adjust = adjust
    interface.properties.distval = tolerance
    interface.properties.rotate_normals = rotate_normals
    interface.properties.dual_basis = dual_basis
    interface.properties.use_forwarddiff = use_forwarddiff
    interface.assembly.u = zeros(2*length(mesh.nodes))
    interface.assembly.la = zeros(2*length(mesh.nodes))

    solver = Solver(Linear)
    push!(solver, upper, lower, bc_upper, bc_lower, interface)

    return solver

end

#=

@testset "curved surface with adjust=true, standard lagrange, slave=lower surface, dy=0.0" begin
    # TODO: analytical solution now known, verify using other fem software
    solver = get_model("mesh tie with curved 2d block";
        adjust=false, tolerance=10, dy=-0.1, rotate_normals=true,
        dual_basis=true, use_forwarddiff=true, finite_strain=false,
        geometric_stiffness=false)
    solver()
    interface = solver["interface between upper and lower block"]
    @test isapprox(norm(interface.assembly.u), 0.11339715157447851)
end

@testset "curved surface with adjust=true, dual lagrange, slave=lower surface, dy=0.0" begin
    # TODO: analytical solution now known, verify using other fem software
    solver = get_model("mesh tie with curved 2d block";
        adjust=true, tolerance=10, dy=0.0, rotate_normals=true,
        dual_basis=true, use_forwarddiff=true)
    solver()
    interface = solver["interface between upper and lower block"]
    @test solver.properties.iteration == 2
    # differs -- why?
    @test isapprox(norm(interface.assembly.u), 0.11660422877751599)
end

@testset "curved surface with adjust=true, standard lagrange, slave=lower surface, dy=-0.1" begin
    # TODO: analytical solution now known, verify using other fem software
    solver = get_model("mesh tie with curved 2d block";
        adjust=true, tolerance=10, dy=-0.1, rotate_normals=true,
        dual_basis=false, use_forwarddiff=true)
    solver()
    interface = solver["interface between upper and lower block"]
    @test solver.properties.iteration == 2
    @test isapprox(norm(interface.assembly.u), 0.34230262165505887)
end

@testset "curved surface, adjust=true, dual basis, slave=lower surface, dy=-0.1" begin
    # TODO: analytical solution now known, verify using other fem software
    solver = get_model("mesh tie with curved 2d block";
        adjust=true, tolerance=10, dy=-0.1, rotate_normals=true,
        dual_basis=true, use_forwarddiff=true)
    solver()
    interface = solver["interface between upper and lower block"]
    @test solver.properties.iteration == 2
    @test isapprox(norm(interface.assembly.u), 0.34318800698017704)
end

=#

@testset "compare forwarddiff solution to normal" begin
    X = Dict(
        1 => [0.0, 0.0],
        2 => [1.0, 0.0],
        3 => [0.0, 1.0],
        4 => [1.0, 1.0])
    u = Dict(
        1 => [0.0, 0.0],
        2 => [0.0, 0.0],
        3 => [0.0, 0.0],
        4 => [0.0, 0.0])
    sel1 = Element(Seg2, [1, 2])
    mel1 = Element(Seg2, [3, 4])
    update!([sel1, mel1], "geometry", X)
    update!([sel1, mel1], "displacement", u)
    update!(sel1, "master elements", [mel1])
    p1 = Problem(Mortar, "test 1", 2, "displacement")
    p2 = Problem(Mortar, "test 2", 2, "displacement")
    push!(p1, sel1, mel1)
    push!(p2, sel1, mel1)
    #p1.properties.adjust = true
    p2.properties.use_forwarddiff = true
    #p1.properties.dual_basis = true
    #p2.properties.dual_basis = true
    p2.assembly.u = zeros(8)
    p2.assembly.la = zeros(8)
    assemble!(p1, 0.0)
    assemble!(p2, 0.0)
    @test isapprox(p1.assembly, p2.assembly)

    #=
    empty!(p1.assembly)
    empty!(p2.assembly)
    p1.properties.adjust = true
    p2.properties.adjust = true
    assemble!(p1, 0.0)
    assemble!(p2, 0.0)
    C11 = full(p1.assembly.C1, 4, 8)
    C12 = full(p2.assembly.C1, 4, 8)
    C21 = full(p1.assembly.C2, 4, 8)
    C22 = full(p2.assembly.C2, 4, 8)
    D1 = full(p1.assembly.D)
    D2 = full(p2.assembly.D)
    g1 = full(p1.assembly.g, 4, 1)
    g2 = full(p2.assembly.g, 4, 1)
    println("C1")
    dump(C11)
    dump(C12)
    println("C2")
    dump(C21)
    dump(C22)
    println("D")
    dump(D1)
    dump(D2)
    println("g")
    dump(g1)
    dump(g2)
    @test isapprox(p1.assembly, p2.assembly)
    =#
end


text:
"""
    abstract type AbstractTensorMap{S<:IndexSpace, N₁, N₂} end

Abstract supertype of all tensor maps, i.e. linear maps between tensor products
of vector spaces of type `S<:IndexSpace`. An `AbstractTensorMap` maps from
an input space of type `ProductSpace{S, N₂}` to an output space of type
`ProductSpace{S, N₁}`.
"""
abstract type AbstractTensorMap{S<:IndexSpace, N₁, N₂} end

"""
    const AbstractTensor{S<:IndexSpace, N} = AbstractTensorMap{S, N, 0}

Abstract supertype of all tensors, i.e. elements in the tensor product space
of type `ProductSpace{S, N}`, built from elementary spaces of type `S<:IndexSpace`.

An `AbstractTensor{S, N}` is actually a special case `AbstractTensorMap{S, N, 0}`,
i.e. a tensor map with only non-trivial output space.
"""
const AbstractTensor{S<:IndexSpace, N} = AbstractTensorMap{S, N, 0}

"""
    storagetype(t::AbstractTensorMap)

Return the storage type of the data for the tensor map instance, for example,
Matrix{Float64}. Now we only have this type as DenseMatrix.
"""
storagetype(t::AbstractTensorMap) = storagetype(typeof(t))

similarstoragetype(TT::Type{<:AbstractTensorMap}, ::Type{T}) where {T} =
    Core.Compiler.return_type(similar, Tuple{storagetype(TT), Type{T}})
similarstoragetype(t::AbstractTensorMap, T) = similarstoragetype(typeof(t), T)

"""
    Base.eltype(T::Type{<:AbstractTensorMap})
    Base.eltype(t::AbstractTensorMap)

Element type of the data for the tensormap in storage. Return, for example, `Float64`.
"""
Base.eltype(T::Type{<:AbstractTensorMap}) = eltype(storagetype(T))
Base.eltype(t::AbstractTensorMap) = eltype(typeof(t))

"""
    field(::Type{<:AbstractTensorMap{S}}) where {S<:IndexSpace}
    field(t::AbstractTensorMap)

Return the field type over which a vector space instance or type is defined.
"""
field(::Type{<:AbstractTensorMap{S}}) where {S<:IndexSpace} = field(S)
field(t::AbstractTensorMap) = field(typeof(t))

"""
    spacetype(::Type{<:AbstractTensorMap{S}}) where {S<:IndexSpace}
    spacetype(t::AbstractTensorMap)

Return the ElementarySpace type associated to a AbstractTensorMap instance or type.
"""
spacetype(::Type{<:AbstractTensorMap{S}}) where {S<:IndexSpace} = S
spacetype(t::AbstractTensorMap) = spacetype(typeof(t))

"""
    sectortype(::Type{<:AbstractTensorMap{S}}) where {S<:IndexSpace}
    sectortype(t::AbstractTensorMap) -> Type{<:Sector}

Return the type of sector over which the AbstractTensorMap `t` or type is defined.
"""
sectortype(::Type{<:AbstractTensorMap{S}}) where {S<:IndexSpace} = sectortype(S)
sectortype(t::AbstractTensorMap) = sectortype(typeof(t))

"""
    numout(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂}
    numout(t::AbstractTensorMap) -> Int

Return the number of the index spaces in the codomain of a AbstractTensorMap instance or
type.
"""
numout(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂} = N₁
numout(t::AbstractTensorMap) = numout(typeof(t))
"""
    numin(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂}
    numin(t::AbstractTensorMap) -> Int

Return the number of the index spaces in the domain of a AbstractTensorMap instance or type.
"""
numin(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂} = N₂
numin(t::AbstractTensorMap) = numin(typeof(t))

"""
    numind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂}
    numind(t::AbstractTensorMap) -> Int

Return the total number of the index spaces of a AbstractTensorMap instance or type.
`order` is the alias of `numind`.
"""
numind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂} = N₁ + N₂
numind(t::AbstractTensorMap) = numind(typeof(t))
const order = numind

"""
    codomainind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂}
    codomainind(t::AbstractTensorMap) -> Tuple

Return the indices of the codomain of a tensor map instance or type as a tuple of Int.
"""
codomainind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂} = ntuple(n->n, N₁)
codomainind(t::AbstractTensorMap) = codomainind(typeof(t))

"""
    domainind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂}
    domainind(t::AbstractTensorMap) -> Tuple{Int}

Return the indices of the domain of a tensor map instance or type as a tuple of Int.
"""
domainind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂} = ntuple(n-> N₁+n, N₂)
domainind(t::AbstractTensorMap) = domainind(typeof(t))

"""
    allind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂}
    allind(t::AbstractTensorMap) -> Tuple{Int}

Return all indices of a tensor map instance or type as a tuple of Int.
"""
allind(::Type{<:AbstractTensorMap{<:IndexSpace, N₁, N₂}}) where {N₁, N₂} = ntuple(n->n, N₁+N₂)
allind(t::AbstractTensorMap) = allind(typeof(t))

"""
    codomian(t::AbstractTensorMap)

Return the codomain of the tensor map `t`.

    codomain(t::AbstractTensorMap, i)

Return the `i`th index space of the codomain of the tensor map `t`.
"""
codomain(t::AbstractTensorMap, i) = codomain(t)[i]

"""
    domain(t::AbstractTensorMap)

Return the domain of the tensor map `t`.

    domain(t::AbstractTensorMap, i)

Return the `i`th index space of the domain of the tensor map `t`.
"""
domain(t::AbstractTensorMap, i) = domain(t)[i]

"""
    target(t::AbstractTensorMap)

Return the codomain of the tensor map `t`.
"""
target(t::AbstractTensorMap) = codomain(t) # categorical terminology

"""
    source(t::AbstractTensorMap)

Return the domain of the tensor map `t`.
"""
source(t::AbstractTensorMap) = domain(t) # categorical terminology

"""
    space(t::AbstractTensorMap) -> HomSpace

Return the HomSpace corresponding to the tensor map `t` instance.
"""
space(t::AbstractTensorMap) = HomSpace(codomain(t), domain(t))

"""
    space(t::AbstractTensorMap, i::Int)

Return the `i`th index space of the HomSpace corresponding to the tensor map `t`.
"""
space(t::AbstractTensorMap, i::Int) = space(t)[i]

"""
    dim(t::AbstractTensorMap)

Return the total dimension of the HomSpace corresponding to the tensor map `t`.
"""
dim(t::AbstractTensorMap) = dim(space(t))

"""
    adjointtensorindex(t::AbstractTensorMap{<:IndexSpace, N₁, N₂}, i) where {N₁, N₂} -> Int

Return the index of the `i`th index of the tensor map `t` in its adjoint.
"""
adjointtensorindex(t::AbstractTensorMap{<:IndexSpace, N₁, N₂}, i) where {N₁, N₂} =
    ifelse(i<=N₁, N₂+i, i-N₁)

"""
    adjointtensorindices(t::AbstractTensorMap, indices::IndexTuple)

Return the indices of the `indices` of the tensor map `t` in its adjoint.
"""
adjointtensorindices(t::AbstractTensorMap, indices::IndexTuple) =
    map(i->adjointtensorindex(t, i), indices)

function Base.:(==)(t1::AbstractTensorMap, t2::AbstractTensorMap)
    (codomain(t1) == codomain(t2) && domain(t1) == domain(t2)) || return false
    for c in blocksectors(t1)
        block(t1, c) == block(t2, c) || return false
    end
    return true
end
function Base.hash(t::AbstractTensorMap, h::UInt)
    h = hash(codomain(t), h)
    h = hash(domain(t), h)
    for (c, b) in blocks(t)
        h = hash(c, hash(b, h))
    end
    return h
end

function Base.isapprox(t1::AbstractTensorMap, t2::AbstractTensorMap;
                atol::Real=0, rtol::Real=Base.rtoldefault(eltype(t1), eltype(t2), atol))
    d = norm(t1 - t2)
    if isfinite(d)
        return d <= max(atol, rtol*max(norm(t1), norm(t2)))
    else
        return false
    end
end

# Conversion to Array:
# probably not optimized for speed, only for checking purposes
function Base.convert(::Type{Array}, t::AbstractTensorMap{S, N₁, N₂}) where {S, N₁, N₂}
    I = sectortype(t)
    if I === Trivial
        convert(Array, t[])
    else
        cod = codomain(t)
        dom = domain(t)
        local A
        for (f1, f2) in fusiontrees(t)
            F1 = convert(Array, f1)
            F2 = convert(Array, f2)
            sz1 = size(F1)
            sz2 = size(F2)
            d1 = TupleLabXD.front(sz1)
            d2 = TupleLabXD.front(sz2)
            F = reshape(reshape(F1, TupleLabXD.prod(d1), sz1[end])*reshape(F2, TupleLabXD.prod(d2), sz2[end])', (d1..., d2...))
            if !(@isdefined A)
                if eltype(F) <: Complex
                    T = complex(float(eltype(t)))
                elseif eltype(F) <: Integer
                    T = eltype(t)
                else
                    T = float(eltype(t))
                end
                A = fill(zero(T), (dims(cod)..., dims(dom)...))
            end
            Aslice = StridedView(A)[axes(cod, f1.uncoupled)..., axes(dom, f2.uncoupled)...]
            axpy!(1, StridedView(_kron(convert(Array, t[f1, f2]), F)), Aslice)
        end
        return A
    end
end


text:
include("leap_frog_definitions.jl")
max_hit=500
barrier=10

condition_max_hits(u,t,integrator)= u[5]>max_hit || maximum([abs(u[1]),abs(u[2]),abs(u[3]),abs(u[4])])>barrier
affect_stop!(integrator) = terminate!(integrator)
function condition_hits_PSS(u,t,integrator) # Event when event_f(u,t) == 0
   u[1]
end
function affect_update_iterator!(integrator)
    integrator.u[5]=integrator.u[5]+1
end

callback_max_hits=DiscreteCallback(condition_max_hits,affect_stop!)
callback_hits_PSS=ContinuousCallback(condition_hits_PSS, affect_update_iterator!,nothing)
cb=CallbackSet(callback_hits_PSS, callback_max_hits)

function PSS_function(Q,P, H,  t_end)
    #setting tolerance for determing if vortices move off to infinity
    tol_dist=1e-3

    #for a given Q,P,H with X=0
    Y=Yfind_Aref(Q,P,H)
    if ~isempty(Y)
        u0=zeros(5)
        u0[1]=0 #X
        u0[2]=P #P
        u0[3]=Q #Q
        u0[4]=Y #Y
        u0[5]=0 # counter variable

        #constructor for ODE
        prob = ODEProblem(Eq_of_M,u0,(0., t_end))

        #solve ode , save_everystep=false is important to prevent sol to include all points, not just event points
        # sol=solve(prob, Vern9(),maxiters=1e20, reltol=1e-13,abstol=1e-15,callback=cb,save_start=true,save_end=true,save_everystep=false)
        sol=solve(prob, RK4(),maxiters=1e20, reltol=1e-6,abstol=1e-8,callback=cb,save_start=true,save_end=true,save_everystep=false)

        #find final value to check if energy was conserved
        uf=zeros(5)
        uf[1]=sol[1,end] #X
        uf[2]=sol[2,end] #P
        uf[3]=sol[3,end] #Q
        uf[4]=sol[4,end] #Y
        dH=abs(H_test(uf)-H)

        #output Q, P and dH
        return sol[:,2:end-1][3,:],sol[:,2:end-1][2,:], dH
    else
    #need to return 3 values, dH=1 flags that there is no Y
        return 0,0,1
    end
end


text:
include("GenerateFiles.jl")
using .GenerateFiles

println("generating qnm files")

nr=80
nl=24
s=-2
m=0
l=2
n=0
avals=[0.0,0.5,0.7,0.9]
qnm_tolerance=1e-6
coef_tolerance=1e-6
epsilon=1e-6

generate("",nr,nl,s,m,l,n,avals,qnm_tolerance,coef_tolerance,epsilon)


text:
function AngularRaDecBuilder(arg0::CorrelatedRandomVectorGenerator, arg1::GroundStation, arg2::Frame, arg3::Vector{jdouble}, arg4::Vector{jdouble}, arg5::ObservableSatellite)
    return AngularRaDecBuilder((CorrelatedRandomVectorGenerator, GroundStation, Frame, Vector{jdouble}, Vector{jdouble}, ObservableSatellite), arg0, arg1, arg2, arg3, arg4, arg5)
end

function build(obj::AngularRaDecBuilder, arg0::Vector{SpacecraftState})
    return jcall(obj, "build", AngularRaDec, (Vector{SpacecraftState},), arg0)
end


text:
module LegacyFileReaders
using FileIO
import FileIO.load
using Base.Mmap

struct DataHeader
    headersize::UInt32
    samplingrate::UInt32
    nchannels::UInt16
    npoints::UInt64
    transpose::Bool
end

struct DataPacket{T<:Real}
    header::DataHeader
    data::AbstractArray{T,2}
end

datatypes = Dict(1 => UInt8,
                 2 => UInt8,
                 3 => Int8,
                 4 => Int16,
                 5 => Int32,
                 6 => Int64,
                 7 => UInt8,
                 8 => UInt16,
                 9 => UInt32,
                 10 => UInt64,
                 11 => Float16,
                 12 => Float32,
                 13 => Float64,
                 14 => Float64)

function FileIO.load(ff::File{format"NPTD"})
    datatype = Int16
    header = open(ff.filename, "r") do fid
        header_size = read(fid, UInt32)
        if header_size == 73
            num_channels = UInt16(read(fid, UInt8))
            transpose = zero(UInt8)
        elseif header_size == 74
            num_channels = read(fid, UInt16)
            transpose = zero(UInt8)
        else
            num_channels = read(fid, UInt16)
            transpose = read(fid, UInt8)
        end
        sampling_rate = read(fid, UInt32)
        seekend(fid)
        fsize = position(fid)
        npoints = div(fsize - header_size,sizeof(datatype))
        npoints = div(npoints, num_channels)
        DataHeader(header_size, sampling_rate, num_channels, npoints,transpose == one(UInt8))
    end
    fid = open(ff.filename, "r")
    if header.transpose
        data = DataPacket(header, Mmap.mmap(fid, Array{datatype, 2}, (Int(header.npoints), Int(header.nchannels)), Int(header.headersize)))
    else
        data = DataPacket(header, Mmap.mmap(fid, Array{datatype, 2}, (Int(header.nchannels), Int(header.npoints)), Int(header.headersize)))
    end
    data
end
end#module


text:
#=
Generate MarkovChain and DiscreteDP instances randomly.

@author : Daisuke Oyama

=#
import StatsBase: sample
import QuantEcon: MarkovChain, DiscreteDP

# random_markov_chain
"""
    random_markov_chain([rng], n[, k])

Return a randomly sampled MarkovChain instance with `n` states, where each state
has `k` states with positive transition probability.

# Arguments

- `rng::AbstractRNG=GLOBAL_RNG` : Random number generator.
- `n::Integer` : Number of states.
- `k::Integer=n` : Number of nonzero entries in each column of the matrix. Set
  to `n` if none specified.

# Returns

- `mc::MarkovChain` : MarkovChain instance.

# Examples

```julia
julia> using QuantEcon, Random

julia> rng = MersenneTwister(1234);

julia> mc = random_markov_chain(rng, 3);

julia> mc.p
3×3 LinearAlgebra.Transpose{Float64,Array{Float64,2}}:
 0.590845  0.175952   0.233203
 0.460085  0.106152   0.433763
 0.794026  0.0601209  0.145853

julia> mc = random_markov_chain(rng, 3, 2);

julia> mc.p
3×3 LinearAlgebra.Transpose{Float64,Array{Float64,2}}:
 0.0       0.200586  0.799414
 0.701386  0.0       0.298614
 0.753163  0.246837  0.0
```
"""
function random_markov_chain(rng::AbstractRNG, n::Integer, k::Integer=n)
    p = random_stochastic_matrix(rng, n, k)
    mc = MarkovChain(p)
    return mc
end

random_markov_chain(n::Integer, k::Integer=n) =
    random_markov_chain(Random.GLOBAL_RNG, n, k)

# random_stochastic_matrix

"""
    random_stochastic_matrix([rng], n[, k])

Return a randomly sampled `n x n` stochastic matrix with `k` nonzero entries for
each row.

# Arguments

- `rng::AbstractRNG=GLOBAL_RNG` : Random number generator.
- `n::Integer` : Number of states.
- `k::Integer=n` : Number of nonzero entries in each column of the matrix. Set
  to `n` if none specified.

# Returns

- `p::Array` : Stochastic matrix.
"""
function random_stochastic_matrix(rng::AbstractRNG, n::Integer, k::Integer=n)
    if !(n > 0)
        throw(ArgumentError("n must be a positive integer"))
    end
    if !(k > 0 && k <= n)
        throw(ArgumentError("k must be an integer with 0 < k <= n"))
    end

    p = _random_stochastic_matrix(rng, n, n, k=k)

    return transpose(p)
end

random_stochastic_matrix(n::Integer, k::Integer=n) =
    random_stochastic_matrix(Random.GLOBAL_RNG, n, k)

"""
    _random_stochastic_matrix([rng], n, m; k=n)

Generate a "non-square column stochstic matrix" of shape `(n, m)`, which contains
as columns `m` probability vectors of length `n` with `k` nonzero entries.

# Arguments

- `rng::AbstractRNG=GLOBAL_RNG` : Random number generator.
- `n::Integer` : Number of states.
- `m::Integer` : Number of probability vectors.
- `;k::Integer(n)` : Number of nonzero entries in each column of the matrix. Set
  to `n` if none specified.

# Returns

- `p::Array` : Array of shape `(n, m)` containing `m` probability vectors of
  length `n` as columns.
"""
function _random_stochastic_matrix(rng::AbstractRNG, n::Integer, m::Integer;
                                   k::Integer=n)
    probvecs = random_probvec(rng, k, m)

    k == n && return probvecs

    # if k < n
    # Randomly sample row indices for each column for nonzero values
    row_indices = Vector{Int}(undef, k*m)
    for j in 1:m
        row_indices[(j-1)*k+1:j*k] = sample(rng, 1:n, k, replace=false)
    end

    p = zeros(n, m)
    for j in 1:m
        for i in 1:k
            p[row_indices[(j-1)*k+i], j] = probvecs[i, j]
        end
    end

    return p
end

_random_stochastic_matrix(n::Integer, m::Integer; k::Integer=n) =
    _random_stochastic_matrix(Random.GLOBAL_RNG, n, m, k=k)

# random_discrete_dp

"""
    random_discrete_dp([rng], num_states, num_actions[, beta];
                       k=num_states, scale=1)

Generate a DiscreteDP randomly. The reward values are drawn from the normal
distribution with mean 0 and standard deviation `scale`.

# Arguments

- `rng::AbstractRNG=GLOBAL_RNG` : Random number generator.
- `num_states::Integer` : Number of states.
- `num_actions::Integer` : Number of actions.
- `beta::Real=rand(rng)` : Discount factor. Randomly chosen from
  `[0, 1)` if not specified.
- `;k::Integer(num_states)` : Number of possible next states for each
  state-action pair. Equal to `num_states` if not specified.
- `scale::Real(1)` : Standard deviation of the normal distribution for the
  reward values.

# Returns

- `ddp::DiscreteDP` : An instance of DiscreteDP.
"""
function random_discrete_dp(rng::AbstractRNG,
                            num_states::Integer,
                            num_actions::Integer,
                            beta::Real=rand(rng);
                            k::Integer=num_states,
                            scale::Real=1)
    L = num_states * num_actions
    R = scale * randn(rng, L)
    Q = _random_stochastic_matrix(rng, num_states, L; k=k)

    R = reshape(R, num_states, num_actions)
    Q = reshape(transpose(Q), num_states, num_actions, num_states)

    ddp = DiscreteDP(R, Q, beta)
    return ddp
end

random_discrete_dp(num_states::Integer, num_actions::Integer,
                   beta::Real=rand(); k::Integer=k, scale::Real=1) =
    random_discrete_dp(Random.GLOBAL_RNG, num_states, num_actions, beta,
                       k=k, scale=scale)

# random_probvec

"""
    random_probvec([rng], k[, m])

Return `m` randomly sampled probability vectors of size `k`.

# Arguments

- `rng::AbstractRNG=GLOBAL_RNG` : Random number generator.
- `k::Integer` : Size of each probability vector.
- `m::Integer` : Number of probability vectors.

# Returns

- `a::Array` : Matrix of shape `(k, m)`, or Vector of shape `(k,)` if `m` is not
  specified, containing probability vector(s) as column(s).
"""
function random_probvec(rng::AbstractRNG, k::Integer, m::Integer)
    k == 1 && return ones((k, m))

    # if k >= 2
    x = Matrix{Float64}(undef, k, m)

    r = rand(rng, k-1, m)
    x[1:end .- 1, :] = sort(r, dims = 1)

    for j in 1:m
        x[end, j] = 1 - x[end-1, j]
        for i in k-1:-1:2
            x[i, j] -= x[i-1, j]
        end
    end

    return x
end

random_probvec(k::Integer, m::Integer) = random_probvec(Random.GLOBAL_RNG, k, m)

random_probvec(rng::AbstractRNG, k::Integer) = vec(random_probvec(rng, k, 1))
random_probvec(k::Integer) = random_probvec(Random.GLOBAL_RNG, k)


text:
""" Extends the matrices u,v,η with a halo of ghost points for boundary conditions. """
function add_halo(u,v,η,sst)
    if VERSION == v"0.6.1"  # cat function was different back then
        u = cat(1,zeros(Numtype,halo,nuy),u,zeros(Numtype,halo,nuy))
        u = cat(2,zeros(Numtype,nux+2*halo,halo),u,zeros(Numtype,nux+2*halo,halo))

        v = cat(1,zeros(Numtype,halo,nvy),v,zeros(Numtype,halo,nvy))
        v = cat(2,zeros(Numtype,nvx+2*halo,halo),v,zeros(Numtype,nvx+2*halo,halo))

        # and haloη for η
        η = cat(1,zeros(Numtype,haloη,ny),η,zeros(Numtype,haloη,ny))
        η = cat(2,zeros(Numtype,nx+2*haloη,haloη),η,zeros(Numtype,nx+2*haloη,haloη))

        sst = cat(1,zeros(Numtype,halosstx,ny),sst,zeros(Numtype,halosstx,ny))
        sst = cat(2,zeros(Numtype,nx+2*halosstx,halossty),sst,zeros(Numtype,nx+2*halosstx,halossty))

    else
        # use halo = number of halo rows/columns to either side for u,v
        u = cat(zeros(Numtype,halo,nuy),u,zeros(Numtype,halo,nuy),dims=1)
        u = cat(zeros(Numtype,nux+2*halo,halo),u,zeros(Numtype,nux+2*halo,halo),dims=2)

        v = cat(zeros(Numtype,halo,nvy),v,zeros(Numtype,halo,nvy),dims=1)
        v = cat(zeros(Numtype,nvx+2*halo,halo),v,zeros(Numtype,nvx+2*halo,halo),dims=2)

        # and haloη for η
        η = cat(zeros(Numtype,haloη,ny),η,zeros(Numtype,haloη,ny),dims=1)
        η = cat(zeros(Numtype,nx+2*haloη,haloη),η,zeros(Numtype,nx+2*haloη,haloη),dims=2)

        sst = cat(zeros(Numtype,halosstx,ny),sst,zeros(Numtype,halosstx,ny),dims=1)
        sst = cat(zeros(Numtype,nx+2*halosstx,halossty),sst,zeros(Numtype,nx+2*halosstx,halossty),dims=2)
    end

    ghost_points!(u,v,η)
    ghost_points_sst!(sst)
    return u,v,η,sst
end

""" Copy ghost points for u from inside to the halo in the nonperiodic case. """
function ghost_points_u_nonperiodic!(u)

    # kinematic boundary condition
    # these values shouldn't change during a time step
    # u[1,:] = zeero
    # u[2,:] = zeero
    # u[end-1,:] = zeero
    # u[end,:] = zeero

    # tangential boundary condition
    @views @inbounds u[:,1] .= one_minus_α*u[:,4]
    @views @inbounds u[:,2] .= one_minus_α*u[:,3]
    @views @inbounds u[:,end-1] .= one_minus_α*u[:,end-2]
    @views @inbounds u[:,end] .= one_minus_α*u[:,end-3]
end

""" Copy ghost points for u from inside to the halo in the periodic case. """
function ghost_points_u_periodic!(u)

    # periodic bc
    @views @inbounds u[1,:] .= u[end-3,:]
    @views @inbounds u[2,:] .= u[end-2,:]
    @views @inbounds u[end-1,:] .= u[3,:]
    @views @inbounds u[end,:] .= u[4,:]

    # tangential bc
    @views @inbounds u[:,1] .= one_minus_α*u[:,4]
    @views @inbounds u[:,2] .= one_minus_α*u[:,3]
    @views @inbounds u[:,end-1] .= one_minus_α*u[:,end-2]
    @views @inbounds u[:,end] .= one_minus_α*u[:,end-3]
end

""" Copy ghost points for u with MPI communication. Boundary conditions are contained within the neighbours array. """
function ghost_points_u_MPI!(u)

    # north
    if nbours[1] != -1 # if north neighbour does exist
        #TODO MPI send/receive
        @views @inbounds u[:,end-1] .= one_minus_α*u[:,end-2]
        @views @inbounds u[:,end] .= one_minus_α*u[:,end-3]
    else
        @views @inbounds u[:,end-1] .= one_minus_α*u[:,end-2]
        @views @inbounds u[:,end] .= one_minus_α*u[:,end-3]
    end

    # east
    if nbours[2] != -1  # if east neighbour does exist
        #TODO MPI send/receive
        @views @inbounds u[end-1,:] .= u[3,:]
        @views @inbounds u[end,:] .= u[4,:]
    else
        # Redundant?
        # u[end-1,:] = zeero
        # u[end,:] = zeero
    end

    # south
    if nbours[3] != -1 # if south neighbour does exist
        #TODO MPI send/receive
        @views @inbounds u[:,end-1] .= one_minus_α*u[:,end-2]
        @views @inbounds u[:,end] .= one_minus_α*u[:,end-3]
    else
        @views @inbounds u[:,end-1] .= one_minus_α*u[:,end-2]
        @views @inbounds u[:,end] .= one_minus_α*u[:,end-3]
    end

    # west
    if nbours[4] != -1  # if west neighbour does exist
        #TODO MPI send/receive
        @views @inbounds u[1,:] .= u[end-3,:]
        @views @inbounds u[2,:] .= u[end-2,:]
    else
        # potentially redundant lines
        # u[1,:] = zeero
        # u[2,:] = zeero
    end
end

""" Copy ghost points for v from inside to the halo in the nonperiodic case. """
function ghost_points_v_nonperiodic!(v)

    # kinematic boundary condition
    # these values shouldn't change during a time step
    # v[:,1] .= zeero
    # v[:,2] .= zeero
    # v[:,end-1] .= zeero
    # v[:,end] .= zeero

    # tangential boundary condition
    @views @inbounds v[1,:] .= one_minus_α*v[4,:]
    @views @inbounds v[2,:] .= one_minus_α*v[3,:]
    @views @inbounds v[end-1,:] .= one_minus_α*v[end-2,:]
    @views @inbounds v[end,:] .= one_minus_α*v[end-3,:]
end

""" Copy ghost points for v from inside to the halo in the periodic case. """
function ghost_points_v_periodic!(v)

    # kinematic boundary condition
    # these values shouldn't change during a time step
    # v[:,1] .= zeero
    # v[:,2] .= zeero
    # v[:,end-1] .= zeero
    # v[:,end] .= zeero

    # tangential boundary condition
    @views @inbounds v[1,:] .= v[end-3,:]
    @views @inbounds v[2,:] .= v[end-2,:]
    @views @inbounds v[end-1,:] .= v[3,:]
    @views @inbounds v[end,:] .= v[4,:]
end

""" Copy ghost points for η from inside to the halo in the nonperiodic case. """
function ghost_points_η_nonperiodic!(η)

    # assume no gradients of η across solid boundaries
    # the 4 corner points are copied twice, but it's faster!
    @views @inbounds η[1,:] .= η[2,:]
    @views @inbounds η[end,:] .= η[end-1,:]

    @views @inbounds η[:,1] .= η[:,2]
    @views @inbounds η[:,end] .= η[:,end-1]
end

""" Copy ghost points for η from inside to the halo in the periodic case. """
function ghost_points_η_periodic!(η)

    # corner points are copied twice, but it's faster!
    @views @inbounds η[1,:] .= η[end-1,:]
    @views @inbounds η[end,:] .= η[2,:]

    @views @inbounds η[:,1] .= η[:,2]
    @views @inbounds η[:,end] .= η[:,end-1]
end

""" Copy ghost points for η from inside to the halo in the nonperiodic case. """
function ghost_points_sst_nonperiodic!(sst)

    # assume no gradients of η across solid boundaries
    # the 4 corner points are copied twice, but it's faster!
    for i ∈ 1:halosstx
        @views @inbounds sst[i,:] .= sst[halosstx+1,:]
        @views @inbounds sst[end-i+1,:] .= sst[end-halosstx,:]
    end

    for j ∈ 1:halossty
        @views @inbounds sst[:,j] .= sst[:,halossty+1]
        @views @inbounds sst[:,end-j+1] .= sst[:,end-halossty]
    end
end

""" Copy ghost points for η from inside to the halo in the periodic case. """
function ghost_points_sst_periodic!(sst)

    # corner points are copied twice, but it's faster!
    for i ∈ 1:halosstx
        @views @inbounds sst[i,:] .= sst[end-2*halosstx+i,:]
        @views @inbounds sst[end-halosstx+i,:] .= sst[halosstx+i,:]
    end

    for j ∈ 1:halossty
        @views @inbounds sst[:,j] .= sst[:,halossty+1]
        @views @inbounds sst[:,end-j+1] .= sst[:,end-halossty]
    end
end

# gather and rename functions for convenience
function ghost_points_periodic!(u,v,η)

    ghost_points_u_periodic!(u)
    ghost_points_v_periodic!(v)
    ghost_points_η_periodic!(η)

end

function ghost_points_nonperiodic!(u,v,η)

    ghost_points_u_nonperiodic!(u)
    ghost_points_v_nonperiodic!(v)
    ghost_points_η_nonperiodic!(η)

end

# pick the right set of functions depending on boundary conditions
if bc_x == "periodic"
    ghost_points! = ghost_points_periodic!
    ghost_points_sst! = ghost_points_sst_periodic!
else
    ghost_points! = ghost_points_nonperiodic!
    ghost_points_sst! = ghost_points_sst_nonperiodic!
end

max_stars_repo_name: eschnett/juls

max_issues_repo_name: eschnett/juls

max_forks_repo_name: eschnett/juls