
(SDEFUN |TMFORM;CorkFunc| ((% (|HashTable| (|SingleInteger|) (|String|) "EQ")))
        (SPADCALL
         (LIST (CONS 60 "<less>") (CONS 62 "<gtr>") (CONS 160 "<varspace>")
               (CONS 162 "<cent>") (CONS 163 "<sterling>")
               (CONS 164 "<currency>") (CONS 165 "<yen>")
               (CONS 166 "<brokenvert>") (CONS 169 "<copyright>")
               (CONS 170 "<ordfeminine>") (CONS 171 "<guillemotleft>")
               (CONS 172 "<neg>") (CONS 173 "<hyphen>") (CONS 174 "<circledR>")
               (CONS 176 "<degree>") (CONS 177 "<pm>")
               (CONS 178 "<twosuperior>") (CONS 179 "<threesuperior>")
               (CONS 181 "<mu>") (CONS 182 "<paragraph>")
               (CONS 183 "<centerdot>") (CONS 185 "<onesuperior>")
               (CONS 186 "<masculine>") (CONS 188 "<onequarter>")
               (CONS 189 "<onehalf>") (CONS 190 "<threequarters>")
               (CONS 215 "<times>") (CONS 247 "<div>") (CONS 8209 "<nbhyph>")
               (CONS 8214 "<||>") (CONS 8224 "<dagger>")
               (CONS 8225 "<ddagger>") (CONS 8226 "<bullet>") (CONS 8230 "...")
               (CONS 8242 "<prime>") (CONS 8245 "<backprime>")
               (CONS 8450 "<bbb-C>") (CONS 8458 "<cal-g>")
               (CONS 8459 "<cal-H>") (CONS 8460 "<frak-H>")
               (CONS 8461 "<bbb-H>") (CONS 8463 "<hslash>")
               (CONS 8464 "<cal-I>") (CONS 8465 "<frak-I>")
               (CONS 8466 "<cal-L>") (CONS 8467 "<ell>") (CONS 8469 "<bbb-N>")
               (CONS 8472 "<wp>") (CONS 8473 "<bbb-P>") (CONS 8474 "<bbb-Q>")
               (CONS 8475 "<cal-R>") (CONS 8476 "<frak-R>")
               (CONS 8477 "<bbb-R>") (CONS 8482 "<trademark>")
               (CONS 8484 "<bbb-Z>") (CONS 8487 "<Mho>") (CONS 8488 "<frak-Z>")
               (CONS 8492 "<cal-B>") (CONS 8493 "<frak-C>")
               (CONS 8495 "<cal-e>") (CONS 8496 "<cal-E>")
               (CONS 8497 "<cal-F>") (CONS 8499 "<cal-M>")
               (CONS 8500 "<cal-o>") (CONS 8501 "<aleph>") (CONS 8502 "<beth>")
               (CONS 8503 "<gimel>") (CONS 8504 "<daleth>")
               (CONS 8592 "<leftarrow>") (CONS 8593 "<uparrow>")
               (CONS 8594 "<rightarrow>") (CONS 8595 "<downarrow>")
               (CONS 8596 "<leftrightarrow>") (CONS 8597 "<updownarrow>")
               (CONS 8598 "<nwarrow>") (CONS 8599 "<nearrow>")
               (CONS 8600 "<searrow>") (CONS 8601 "<swarrow>")
               (CONS 8602 "<nleftarrow>") (CONS 8603 "<nrightarrow>")
               (CONS 8604 "<leftsquigarrow>") (CONS 8605 "<rightsquigarrow>")
               (CONS 8606 "<twoheadleftarrow>")
               (CONS 8608 "<twoheadrightarrow>") (CONS 8610 "<leftarrowtail>")
               (CONS 8611 "<rightarrowtail>") (CONS 8612 "<mapsfrom>")
               (CONS 8614 "<mapsto>") (CONS 8617 "<hookleftarrow>")
               (CONS 8618 "<hookrightarrow>") (CONS 8619 "<looparrowleft>")
               (CONS 8620 "<looparrowright>")
               (CONS 8621 "<leftrightsquigarrow>")
               (CONS 8622 "<nleftrightarrow>") (CONS 8623 "<lightning>")
               (CONS 8624 "<Lsh>") (CONS 8625 "<Rsh>")
               (CONS 8630 "<curvearrowleft>") (CONS 8631 "<curvearrowright>")
               (CONS 8634 "<circlearrowleft>") (CONS 8635 "<circlearrowright>")
               (CONS 8636 "<leftharpoonup>") (CONS 8637 "<leftharpoondown>")
               (CONS 8638 "<upharpoonright>") (CONS 8639 "<upharpoonleft>")
               (CONS 8640 "<rightharpoonup>") (CONS 8641 "<rightharpoondown>")
               (CONS 8642 "<downharpoonright>") (CONS 8643 "<downharpoonleft>")
               (CONS 8644 "<rightleftarrows>") (CONS 8646 "<leftrightarrows>")
               (CONS 8647 "<leftleftarrows>") (CONS 8648 "<upuparrows>")
               (CONS 8649 "<rightrightarrows>") (CONS 8650 "<downdownarrows>")
               (CONS 8651 "<leftrightharpoons>")
               (CONS 8652 "<rightleftharpoons>") (CONS 8653 "<nLeftarrow>")
               (CONS 8654 "<nLeftrightarrow>") (CONS 8655 "<nRightarrow>")
               (CONS 8656 "<Leftarrow>") (CONS 8657 "<Uparrow>")
               (CONS 8658 "<Rightarrow>") (CONS 8659 "<Downarrow>")
               (CONS 8660 "<Leftrightarrow>") (CONS 8661 "<Updownarrow>")
               (CONS 8666 "<Lleftarrow>") (CONS 8667 "<Rrightarrow>")
               (CONS 8704 "<forall>") (CONS 8705 "<complement>")
               (CONS 8706 "<partial>") (CONS 8707 "<exists>")
               (CONS 8708 "<nexists>") (CONS 8709 "<emptyset>")
               (CONS 8711 "<nabla>") (CONS 8712 "<in>") (CONS 8713 "<nin>")
               (CONS 8715 "<ni>") (CONS 8716 "<nni>") (CONS 8719 "<big-prod>")
               (CONS 8720 "<big-amalg>") (CONS 8721 "<big-sum>")
               (CONS 8722 "<minus>") (CONS 8723 "<mp>") (CONS 8724 "<dotplus>")
               (CONS 8726 "<setminus>") (CONS 8727 "<ast>")
               (CONS 8728 "<circ>") (CONS 8730 "<sqrt>") (CONS 8733 "<propto>")
               (CONS 8734 "<infty>") (CONS 8736 "<angle>")
               (CONS 8737 "<measuredangle>") (CONS 8738 "<sphericalangle>")
               (CONS 8739 "<mid>") (CONS 8740 "<nmid>")
               (CONS 8741 "<parallel>") (CONS 8742 "<nparallel>")
               (CONS 8743 "<wedge>") (CONS 8744 "<vee>") (CONS 8745 "<cap>")
               (CONS 8746 "<cup>") (CONS 8747 "<big-int>")
               (CONS 8750 "<big-oint>") (CONS 8756 "<therefore>")
               (CONS 8757 "<because>") (CONS 8764 "<sim>")
               (CONS 8765 "<backsim>") (CONS 8768 "<wr>") (CONS 8769 "<nsim>")
               (CONS 8770 "<eqsim>") (CONS 8771 "<simeq>")
               (CONS 8772 "<nsimeq>") (CONS 8773 "<cong>")
               (CONS 8775 "<ncong>") (CONS 8776 "<approx>")
               (CONS 8777 "<napprox>") (CONS 8778 "<approxeq>")
               (CONS 8781 "<asymp>") (CONS 8782 "<Bumpeq>")
               (CONS 8783 "<bumpeq>") (CONS 8784 "<doteq>")
               (CONS 8785 "<doteqdot>") (CONS 8786 "<fallingdoteq>")
               (CONS 8787 "<risingdoteq>") (CONS 8788 "<assign>")
               (CONS 8790 "<eqcirc>") (CONS 8791 "<circeq>")
               (CONS 8796 "<triangleq>") (CONS 8800 "<neq>")
               (CONS 8801 "<equiv>") (CONS 8802 "<nequiv>") (CONS 8804 "<leq>")
               (CONS 8805 "<geq>") (CONS 8806 "<leqq>") (CONS 8807 "<geqq>")
               (CONS 8808 "<lneqq>") (CONS 8809 "<gneqq>") (CONS 8810 "<ll>")
               (CONS 8811 "<gg>") (CONS 8812 "<between>")
               (CONS 8813 "<nasymp>") (CONS 8814 "<nless>")
               (CONS 8815 "<ngtr>") (CONS 8816 "<nleq>") (CONS 8817 "<ngeq>")
               (CONS 8818 "<lesssim>") (CONS 8819 "<gtrsim>")
               (CONS 8822 "<lessgtr>") (CONS 8823 "<gtrless>")
               (CONS 8826 "<prec>") (CONS 8827 "<succ>")
               (CONS 8828 "<preccurlyeq>") (CONS 8829 "<succcurlyeq>")
               (CONS 8830 "<precsim>") (CONS 8831 "<succsim>")
               (CONS 8832 "<nprec>") (CONS 8833 "<nsucc>")
               (CONS 8834 "<subset>") (CONS 8835 "<supset>")
               (CONS 8836 "<nsubset>") (CONS 8837 "<nsupset>")
               (CONS 8838 "<subseteq>") (CONS 8839 "<supseteq>")
               (CONS 8840 "<nsubseteq>") (CONS 8841 "<nsupseteq>")
               (CONS 8842 "<subsetneq>") (CONS 8843 "<supsetneq>")
               (CONS 8846 "<uplus>") (CONS 8847 "<sqsubset>")
               (CONS 8848 "<sqsupset>") (CONS 8849 "<sqsubseteq>")
               (CONS 8850 "<sqsupseteq>") (CONS 8851 "<sqcap>")
               (CONS 8852 "<sqcup>") (CONS 8853 "<varoplus>")
               (CONS 8854 "<varominus>") (CONS 8855 "<varotimes>")
               (CONS 8856 "<varoslash>") (CONS 8857 "<varodot>")
               (CONS 8858 "<varocircle>") (CONS 8859 "<varoast>")
               (CONS 8861 "<circleddash>") (CONS 8862 "<boxplus>")
               (CONS 8863 "<boxminus>") (CONS 8864 "<boxtimes>")
               (CONS 8865 "<boxdot>") (CONS 8866 "<vdash>")
               (CONS 8867 "<dashv>") (CONS 8868 "<top>") (CONS 8869 "<bot>")
               (CONS 8871 "<models>") (CONS 8872 "<vDash>")
               (CONS 8873 "<Vdash>") (CONS 8874 "<Vvdash>")
               (CONS 8876 "<nvdash>") (CONS 8877 "<nvDash>")
               (CONS 8878 "<nVdash>") (CONS 8879 "<nVDash>")
               (CONS 8882 "<vartriangleleft>") (CONS 8883 "<vartriangleright>")
               (CONS 8884 "<trianglelefteq>") (CONS 8885 "<trianglerighteq>")
               (CONS 8888 "<multimap>") (CONS 8890 "<intercal>")
               (CONS 8891 "<veebar>") (CONS 8896 "<big-wedge>")
               (CONS 8897 "<big-vee>") (CONS 8898 "<big-cap>")
               (CONS 8899 "<big-cup>") (CONS 8900 "<diamond>")
               (CONS 8901 "<cdot>") (CONS 8902 "<star>")
               (CONS 8903 "<divideontimes>") (CONS 8904 "<join>")
               (CONS 8905 "<ltimes>") (CONS 8906 "<rtimes>")
               (CONS 8907 "<leftthreetimes>") (CONS 8908 "<rightthreetimes>")
               (CONS 8909 "<backsimeq>") (CONS 8910 "<curlyvee>")
               (CONS 8911 "<curlywedge>") (CONS 8912 "<Subset>")
               (CONS 8913 "<Supset>") (CONS 8914 "<Cap>") (CONS 8915 "<Cup>")
               (CONS 8916 "<pitchfork>") (CONS 8918 "<lessdot>")
               (CONS 8919 "<gtrdot>") (CONS 8920 "<lll>") (CONS 8921 "<ggg>")
               (CONS 8922 "<lesseqgtr>") (CONS 8923 "<gtreqless>")
               (CONS 8926 "<curlyeqprec>") (CONS 8927 "<curlyeqsucc>")
               (CONS 8928 "<npreccurlyeq>") (CONS 8929 "<nsucccurlyeq>")
               (CONS 8930 "<nsqsubseteq>") (CONS 8931 "<nsqsupseteq>")
               (CONS 8934 "<lnsim>") (CONS 8935 "<gnsim>")
               (CONS 8936 "<precnsim>") (CONS 8937 "<succnsim>")
               (CONS 8938 "<ntriangleleft>") (CONS 8939 "<ntriangleright>")
               (CONS 8940 "<ntrianglelefteq>") (CONS 8941 "<ntrianglerighteq>")
               (CONS 8942 "<vdots>") (CONS 8943 "<cdots>")
               (CONS 8944 "<udots>") (CONS 8945 "<ddots>")
               (CONS 8960 "<diameter>") (CONS 8965 "<barwedge>")
               (CONS 8966 "<doublebarwedge>") (CONS 8968 "<lceil>")
               (CONS 8969 "<rceil>") (CONS 8970 "<lfloor>")
               (CONS 8971 "<rfloor>") (CONS 8976 "<invneg>")
               (CONS 8981 "<recorder>") (CONS 8988 "<ulcorner>")
               (CONS 8989 "<urcorner>") (CONS 8990 "<llcorner>")
               (CONS 8991 "<lrcorner>") (CONS 8994 "<frown>")
               (CONS 8995 "<smile>") (CONS 9016 "<talloblong>")
               (CONS 9031 "<APLleftarrowbox>") (CONS 9032 "<APLrightarrowbox>")
               (CONS 9040 "<APLuparrowbox>") (CONS 9047 "<APLdownarrowbox>")
               (CONS 9054 "<APLinput>") (CONS 9109 "<APLbox>")
               (CONS 9416 "<circledS>") (CONS 9632 "<blacksquare>")
               (CONS 9633 "<Square>") (CONS 9647 "<oblong>")
               (CONS 9651 "<bigtriangleup>") (CONS 9652 "<blacktriangle>")
               (CONS 9653 "<vartriangle>") (CONS 9656 "<blacktriangleright>")
               (CONS 9657 "<triangleright>") (CONS 9661 "<bigtriangledown>")
               (CONS 9662 "<blacktriangledown>") (CONS 9663 "<triangledown>")
               (CONS 9666 "<blacktriangleleft>") (CONS 9667 "<triangleleft>")
               (CONS 9671 "<wasyDiamond>") (CONS 9674 "<lozenge>")
               (CONS 9675 "<Circle>") (CONS 9679 "<CIRCLE>")
               (CONS 9680 "<LEFTcircle>") (CONS 9681 "<RIGHTcircle>")
               (CONS 9686 "<LEFTCIRCLE>") (CONS 9687 "<RIGHTCIRCLE>")
               (CONS 9711 "<varbigcirc>") (CONS 9725 "<square>")
               (CONS 9733 "<bigstar>") (CONS 9737 "<astrosun>")
               (CONS 9738 "<ascnode>") (CONS 9739 "<descnode>")
               (CONS 9740 "<conjunction>") (CONS 9741 "<opposition>")
               (CONS 9742 "<phone>") (CONS 9745 "<XBox>")
               (CONS 9746 "<CheckedBox>") (CONS 9785 "<frownie>")
               (CONS 9786 "<smiley>") (CONS 9787 "<blacksmiley>")
               (CONS 9788 "<sun>") (CONS 9789 "<rightmoon>")
               (CONS 9790 "<leftmoon>") (CONS 9791 "<mercury>")
               (CONS 9792 "<female>") (CONS 9793 "<earth>")
               (CONS 9794 "<male>") (CONS 9795 "<jupiter>")
               (CONS 9796 "<saturn>") (CONS 9797 "<uranus>")
               (CONS 9798 "<neptune>") (CONS 9799 "<pluto>")
               (CONS 9800 "<aries>") (CONS 9801 "<taurus>")
               (CONS 9802 "<gemini>") (CONS 9803 "<cancer>")
               (CONS 9804 "<leo>") (CONS 9805 "<virgo>") (CONS 9806 "<libra>")
               (CONS 9807 "<scorpio>") (CONS 9808 "<sagittarius>")
               (CONS 9809 "<capricornus>") (CONS 9810 "<aquarius>")
               (CONS 9811 "<pisces>") (CONS 9824 "<spadesuit>")
               (CONS 9827 "<clubsuit>") (CONS 9829 "<heartsuit>")
               (CONS 9830 "<diamondsuit>") (CONS 9833 "<quarternote>")
               (CONS 9834 "<eighthnote>") (CONS 9835 "<twonotes>")
               (CONS 9837 "<flat>") (CONS 9838 "<natural>")
               (CONS 9839 "<sharp>") (CONS 10003 "<checkmark>")
               (CONS 913 "<Alpha>") (CONS 914 "<Beta>") (CONS 915 "<Gamma>")
               (CONS 916 "<Delta>") (CONS 917 "<Epsilon>") (CONS 918 "<Zeta>")
               (CONS 919 "<Eta>") (CONS 920 "<Theta>") (CONS 921 "<Iota>")
               (CONS 922 "<Kappa>") (CONS 923 "<Lambda>") (CONS 924 "<Mu>")
               (CONS 925 "<Nu>") (CONS 926 "<Xi>") (CONS 927 "<Omicron>")
               (CONS 928 "<Pi>") (CONS 929 "<Rho>") (CONS 931 "<Sigma>")
               (CONS 932 "<Tau>") (CONS 933 "<Upsilon>") (CONS 934 "<Phi>")
               (CONS 935 "<Chi>") (CONS 936 "<Psi>") (CONS 937 "<Omega>")
               (CONS 945 "<alpha>") (CONS 946 "<beta>") (CONS 947 "<gamma>")
               (CONS 948 "<delta>") (CONS 949 "<varepsilon>")
               (CONS 950 "<zeta>") (CONS 951 "<eta>") (CONS 952 "<theta>")
               (CONS 953 "<iota>") (CONS 954 "<kappa>") (CONS 955 "<lambda>")
               (CONS 956 "<mu>") (CONS 957 "<nu>") (CONS 958 "<xi>")
               (CONS 959 "<omicron>") (CONS 960 "<pi>") (CONS 961 "<rho>")
               (CONS 962 "<varsigma>") (CONS 963 "<sigma>") (CONS 964 "<tau>")
               (CONS 965 "<upsilon>") (CONS 966 "<varphi>") (CONS 967 "<chi>")
               (CONS 968 "<psi>") (CONS 969 "<omega>") (CONS 977 "<vartheta>")
               (CONS 981 "<phi>") (CONS 982 "<varpi>") (CONS 989 "<digamma>")
               (CONS 1008 "<varkappa>") (CONS 1009 "<varrho>")
               (CONS 1013 "<epsilon>") (CONS 65309 "<longequal>")
               (CONS 119808 "<b-up-A>") (CONS 119809 "<b-up-B>")
               (CONS 119810 "<b-up-C>") (CONS 119811 "<b-up-D>")
               (CONS 119812 "<b-up-E>") (CONS 119813 "<b-up-F>")
               (CONS 119814 "<b-up-G>") (CONS 119815 "<b-up-H>")
               (CONS 119816 "<b-up-I>") (CONS 119817 "<b-up-J>")
               (CONS 119818 "<b-up-K>") (CONS 119819 "<b-up-L>")
               (CONS 119820 "<b-up-M>") (CONS 119821 "<b-up-N>")
               (CONS 119822 "<b-up-O>") (CONS 119823 "<b-up-P>")
               (CONS 119824 "<b-up-Q>") (CONS 119825 "<b-up-R>")
               (CONS 119826 "<b-up-S>") (CONS 119827 "<b-up-T>")
               (CONS 119828 "<b-up-U>") (CONS 119829 "<b-up-V>")
               (CONS 119830 "<b-up-W>") (CONS 119831 "<b-up-X>")
               (CONS 119832 "<b-up-Y>") (CONS 119833 "<b-up-Z>")
               (CONS 119834 "<b-up-a>") (CONS 119835 "<b-up-b>")
               (CONS 119836 "<b-up-c>") (CONS 119837 "<b-up-d>")
               (CONS 119838 "<b-up-e>") (CONS 119839 "<b-up-f>")
               (CONS 119840 "<b-up-g>") (CONS 119841 "<b-up-h>")
               (CONS 119842 "<b-up-i>") (CONS 119843 "<b-up-j>")
               (CONS 119844 "<b-up-k>") (CONS 119845 "<b-up-l>")
               (CONS 119846 "<b-up-m>") (CONS 119847 "<b-up-n>")
               (CONS 119848 "<b-up-o>") (CONS 119849 "<b-up-p>")
               (CONS 119850 "<b-up-q>") (CONS 119851 "<b-up-r>")
               (CONS 119852 "<b-up-s>") (CONS 119853 "<b-up-t>")
               (CONS 119854 "<b-up-u>") (CONS 119855 "<b-up-v>")
               (CONS 119856 "<b-up-w>") (CONS 119857 "<b-up-x>")
               (CONS 119858 "<b-up-y>") (CONS 119859 "<b-up-z>")
               (CONS 119912 "<b-A>") (CONS 119913 "<b-B>")
               (CONS 119914 "<b-C>") (CONS 119915 "<b-D>")
               (CONS 119916 "<b-E>") (CONS 119917 "<b-F>")
               (CONS 119918 "<b-G>") (CONS 119919 "<b-H>")
               (CONS 119920 "<b-I>") (CONS 119921 "<b-J>")
               (CONS 119922 "<b-K>") (CONS 119923 "<b-L>")
               (CONS 119924 "<b-M>") (CONS 119925 "<b-N>")
               (CONS 119926 "<b-O>") (CONS 119927 "<b-P>")
               (CONS 119928 "<b-Q>") (CONS 119929 "<b-R>")
               (CONS 119930 "<b-S>") (CONS 119931 "<b-T>")
               (CONS 119932 "<b-U>") (CONS 119933 "<b-V>")
               (CONS 119934 "<b-W>") (CONS 119935 "<b-X>")
               (CONS 119936 "<b-Y>") (CONS 119937 "<b-Z>")
               (CONS 119938 "<b-a>") (CONS 119939 "<b-b>")
               (CONS 119940 "<b-c>") (CONS 119941 "<b-d>")
               (CONS 119942 "<b-e>") (CONS 119943 "<b-f>")
               (CONS 119944 "<b-g>") (CONS 119945 "<b-h>")
               (CONS 119946 "<b-i>") (CONS 119947 "<b-j>")
               (CONS 119948 "<b-k>") (CONS 119949 "<b-l>")
               (CONS 119950 "<b-m>") (CONS 119951 "<b-n>")
               (CONS 119952 "<b-o>") (CONS 119953 "<b-p>")
               (CONS 119954 "<b-q>") (CONS 119955 "<b-r>")
               (CONS 119956 "<b-s>") (CONS 119957 "<b-t>")
               (CONS 119958 "<b-u>") (CONS 119959 "<b-v>")
               (CONS 119960 "<b-w>") (CONS 119961 "<b-x>")
               (CONS 119962 "<b-y>") (CONS 119963 "<b-z>")
               (CONS 119964 "<cal-A>") (CONS 119966 "<cal-C>")
               (CONS 119967 "<cal-D>") (CONS 119970 "<cal-G>")
               (CONS 119973 "<cal-J>") (CONS 119974 "<cal-K>")
               (CONS 119977 "<cal-N>") (CONS 119978 "<cal-O>")
               (CONS 119979 "<cal-P>") (CONS 119980 "<cal-Q>")
               (CONS 119982 "<cal-S>") (CONS 119983 "<cal-T>")
               (CONS 119984 "<cal-U>") (CONS 119985 "<cal-V>")
               (CONS 119986 "<cal-W>") (CONS 119987 "<cal-X>")
               (CONS 119988 "<cal-Y>") (CONS 119989 "<cal-Z>")
               (CONS 119990 "<cal-a>") (CONS 119991 "<cal-b>")
               (CONS 119992 "<cal-c>") (CONS 119993 "<cal-d>")
               (CONS 119995 "<cal-f>") (CONS 119997 "<cal-h>")
               (CONS 119998 "<cal-i>") (CONS 119999 "<cal-j>")
               (CONS 120000 "<cal-k>") (CONS 120001 "<cal-l>")
               (CONS 120002 "<cal-m>") (CONS 120003 "<cal-n>")
               (CONS 120005 "<cal-p>") (CONS 120006 "<cal-q>")
               (CONS 120007 "<cal-r>") (CONS 120008 "<cal-s>")
               (CONS 120009 "<cal-t>") (CONS 120010 "<cal-u>")
               (CONS 120011 "<cal-v>") (CONS 120012 "<cal-w>")
               (CONS 120013 "<cal-x>") (CONS 120014 "<cal-y>")
               (CONS 120015 "<cal-z>") (CONS 120068 "<frak-A>")
               (CONS 120069 "<frak-B>") (CONS 120071 "<frak-D>")
               (CONS 120072 "<frak-E>") (CONS 120073 "<frak-F>")
               (CONS 120074 "<frak-G>") (CONS 120077 "<frak-J>")
               (CONS 120078 "<frak-K>") (CONS 120079 "<frak-L>")
               (CONS 120080 "<frak-M>") (CONS 120081 "<frak-N>")
               (CONS 120082 "<frak-O>") (CONS 120083 "<frak-P>")
               (CONS 120084 "<frak-Q>") (CONS 120086 "<frak-S>")
               (CONS 120087 "<frak-T>") (CONS 120088 "<frak-U>")
               (CONS 120089 "<frak-V>") (CONS 120090 "<frak-W>")
               (CONS 120091 "<frak-X>") (CONS 120092 "<frak-Y>")
               (CONS 120094 "<frak-a>") (CONS 120095 "<frak-b>")
               (CONS 120096 "<frak-c>") (CONS 120097 "<frak-d>")
               (CONS 120098 "<frak-e>") (CONS 120099 "<frak-f>")
               (CONS 120100 "<frak-g>") (CONS 120101 "<frak-h>")
               (CONS 120102 "<frak-i>") (CONS 120103 "<frak-j>")
               (CONS 120104 "<frak-k>") (CONS 120105 "<frak-l>")
               (CONS 120106 "<frak-m>") (CONS 120107 "<frak-n>")
               (CONS 120108 "<frak-o>") (CONS 120109 "<frak-p>")
               (CONS 120110 "<frak-q>") (CONS 120111 "<frak-r>")
               (CONS 120112 "<frak-s>") (CONS 120113 "<frak-t>")
               (CONS 120114 "<frak-u>") (CONS 120115 "<frak-v>")
               (CONS 120116 "<frak-w>") (CONS 120117 "<frak-x>")
               (CONS 120118 "<frak-y>") (CONS 120119 "<frak-z>")
               (CONS 120120 "<bbb-A>") (CONS 120121 "<bbb-B>")
               (CONS 120123 "<bbb-D>") (CONS 120124 "<bbb-E>")
               (CONS 120125 "<bbb-F>") (CONS 120126 "<bbb-G>")
               (CONS 120128 "<bbb-I>") (CONS 120129 "<bbb-J>")
               (CONS 120130 "<bbb-K>") (CONS 120131 "<bbb-L>")
               (CONS 120132 "<bbb-M>") (CONS 120134 "<bbb-O>")
               (CONS 120138 "<bbb-S>") (CONS 120139 "<bbb-T>")
               (CONS 120140 "<bbb-U>") (CONS 120141 "<bbb-V>")
               (CONS 120142 "<bbb-W>") (CONS 120143 "<bbb-X>")
               (CONS 120144 "<bbb-Y>") (CONS 120146 "<bbb-a>")
               (CONS 120147 "<bbb-b>") (CONS 120148 "<bbb-c>")
               (CONS 120149 "<bbb-d>") (CONS 120150 "<bbb-e>")
               (CONS 120151 "<bbb-f>") (CONS 120152 "<bbb-g>")
               (CONS 120153 "<bbb-h>") (CONS 120154 "<bbb-i>")
               (CONS 120155 "<bbb-j>") (CONS 120156 "<bbb-k>")
               (CONS 120157 "<bbb-l>") (CONS 120158 "<bbb-m>")
               (CONS 120159 "<bbb-n>") (CONS 120160 "<bbb-o>")
               (CONS 120161 "<bbb-p>") (CONS 120162 "<bbb-q>")
               (CONS 120163 "<bbb-r>") (CONS 120164 "<bbb-s>")
               (CONS 120165 "<bbb-t>") (CONS 120166 "<bbb-u>")
               (CONS 120167 "<bbb-v>") (CONS 120168 "<bbb-w>")
               (CONS 120169 "<bbb-x>") (CONS 120170 "<bbb-y>")
               (CONS 120171 "<bbb-z>") (CONS 120488 "<b-Alpha>")
               (CONS 120489 "<b-Beta>") (CONS 120490 "<b-Gamma>")
               (CONS 120491 "<b-Delta>") (CONS 120492 "<b-Epsilon>")
               (CONS 120493 "<b-Zeta>") (CONS 120494 "<b-Eta>")
               (CONS 120495 "<b-Theta>") (CONS 120496 "<b-Iota>")
               (CONS 120497 "<b-Kappa>") (CONS 120498 "<b-Lambda>")
               (CONS 120499 "<b-Mu>") (CONS 120500 "<b-Nu>")
               (CONS 120501 "<b-Xi>") (CONS 120502 "<b-Omicron>")
               (CONS 120503 "<b-Pi>") (CONS 120504 "<b-Rho>")
               (CONS 120506 "<b-Sigma>") (CONS 120507 "<b-Tau>")
               (CONS 120508 "<b-Upsilon>") (CONS 120509 "<b-Phi>")
               (CONS 120510 "<b-Chi>") (CONS 120511 "<b-Psi>")
               (CONS 120512 "<b-Omega>") (CONS 120514 "<b-up-alpha>")
               (CONS 120515 "<b-up-beta>") (CONS 120516 "<b-up-gamma>")
               (CONS 120517 "<b-up-delta>") (CONS 120518 "<b-up-varepsilon>")
               (CONS 120519 "<b-up-zeta>") (CONS 120520 "<b-up-eta>")
               (CONS 120521 "<b-up-theta>") (CONS 120522 "<b-up-iota>")
               (CONS 120523 "<b-up-kappa>") (CONS 120524 "<b-up-lambda>")
               (CONS 120525 "<b-up-mu>") (CONS 120526 "<b-up-nu>")
               (CONS 120527 "<b-up-xi>") (CONS 120528 "<b-up-omicron>")
               (CONS 120529 "<b-up-pi>") (CONS 120530 "<b-up-rho>")
               (CONS 120531 "<b-up-varsigma>") (CONS 120532 "<b-up-sigma>")
               (CONS 120533 "<b-up-tau>") (CONS 120534 "<b-up-upsilon>")
               (CONS 120535 "<b-up-varphi>") (CONS 120536 "<b-up-chi>")
               (CONS 120537 "<b-up-psi>") (CONS 120538 "<b-up-omega>")
               (CONS 120540 "<b-up-epsilon>") (CONS 120541 "<b-up-vartheta>")
               (CONS 120542 "<b-up-varkappa>") (CONS 120543 "<b-up-phi>")
               (CONS 120544 "<b-up-varrho>") (CONS 120545 "<b-up-varpi>")
               (CONS 120630 "<b-alpha>") (CONS 120631 "<b-beta>")
               (CONS 120632 "<b-gamma>") (CONS 120633 "<b-delta>")
               (CONS 120634 "<b-varepsilon>") (CONS 120635 "<b-zeta>")
               (CONS 120636 "<b-eta>") (CONS 120637 "<b-theta>")
               (CONS 120638 "<b-iota>") (CONS 120639 "<b-kappa>")
               (CONS 120640 "<b-lambda>") (CONS 120641 "<b-mu>")
               (CONS 120642 "<b-nu>") (CONS 120643 "<b-xi>")
               (CONS 120644 "<b-omicron>") (CONS 120645 "<b-pi>")
               (CONS 120646 "<b-rho>") (CONS 120647 "<b-varsigma>")
               (CONS 120648 "<b-sigma>") (CONS 120649 "<b-tau>")
               (CONS 120650 "<b-upsilon>") (CONS 120651 "<b-varphi>")
               (CONS 120652 "<b-chi>") (CONS 120653 "<b-psi>")
               (CONS 120654 "<b-omega>") (CONS 120656 "<b-epsilon>")
               (CONS 120657 "<b-vartheta>") (CONS 120658 "<b-varkappa>")
               (CONS 120659 "<b-phi>") (CONS 120660 "<b-varrho>")
               (CONS 120661 "<b-varpi>") (CONS 120782 "<b-0>")
               (CONS 120783 "<b-1>") (CONS 120784 "<b-2>")
               (CONS 120785 "<b-3>") (CONS 120786 "<b-4>")
               (CONS 120787 "<b-5>") (CONS 120788 "<b-6>")
               (CONS 120789 "<b-7>") (CONS 120790 "<b-8>")
               (CONS 120791 "<b-9>"))
         (QREFELT % 9))) 

(SDEFUN |TMFORM;coerce;OfS;2| ((|expr| (|OutputForm|)) (% (|String|)))
        (SPROG ((|s| (|String|)))
               (SEQ
                (LETT |s|
                      (|TMFORM;postcondition|
                       (|TMFORM;formatExpr| (SPADCALL |expr| (QREFELT % 28))
                        (QREFELT % 13) %)
                       %))
                (EXIT |s|)))) 

(PUT '|TMFORM;sayExpr| '|SPADreplace| '|sayTexmacs|) 

(SDEFUN |TMFORM;sayExpr| ((|s| (|String|)) (% (|Void|))) (|sayTexmacs| |s|)) 

(SDEFUN |TMFORM;coerceL;OfS;4| ((|expr| (|OutputForm|)) (% (|String|)))
        (SPROG ((|s| (|String|)))
               (SEQ
                (LETT |s|
                      (|TMFORM;postcondition|
                       (|TMFORM;formatExpr| (SPADCALL |expr| (QREFELT % 28))
                        (QREFELT % 13) %)
                       %))
                (|TMFORM;sayExpr| "scheme: (with \"mode\" \"math\"" %)
                (|TMFORM;sayExpr| |s| %) (|TMFORM;sayExpr| ")" %) (EXIT |s|)))) 

(SDEFUN |TMFORM;display;SV;5| ((|texmacs| (|String|)) (% (|Void|)))
        (SEQ (|TMFORM;sayExpr| "scheme: (with \"mode\" \"math\"" %)
             (|TMFORM;sayExpr| |texmacs| %) (|TMFORM;sayExpr| ")" %)
             (EXIT (SPADCALL (QREFELT % 33))))) 

(PUT '|TMFORM;ungroup| '|SPADreplace| '(XLAM (|str|) |str|)) 

(SDEFUN |TMFORM;ungroup| ((|str| (|String|)) (% (|String|))) |str|) 

(SDEFUN |TMFORM;postcondition| ((|str| (|String|)) (% (|String|)))
        (SPROG
         ((|uend| #1=(|UniversalSegment| (|Integer|))) (|ustart| #1#)
          (|pos| (|Integer|)) (|plusminus| (|String|)) (|len| (|Integer|)))
         (SEQ (LETT |len| (QCSIZE |str|))
              (LETT |plusminus| "\"+\" (concat \"-\"")
              (LETT |pos| (SPADCALL |plusminus| |str| 1 (QREFELT % 36)))
              (COND
               ((> |pos| 0)
                (SEQ (LETT |ustart| (SPADCALL 1 (- |pos| 1) (QREFELT % 38)))
                     (LETT |uend| (SPADCALL (+ |pos| 15) |len| (QREFELT % 38)))
                     (LETT |str|
                           (SPADCALL
                            (LIST (SPADCALL |str| |ustart| (QREFELT % 39))
                                  "(concat \"-\""
                                  (SPADCALL |str| |uend| (QREFELT % 39)))
                            (QREFELT % 41)))
                     (EXIT
                      (COND
                       ((< |pos| (- |len| 13))
                        (LETT |str| (|TMFORM;postcondition| |str| %))))))))
              (EXIT |str|)))) 

(SDEFUN |TMFORM;optionalWrap|
        ((|s| (|String|)) (|expr| (|OutputForm|)) (|prec| (|Integer|))
         (% (|String|)))
        (SPROG ((|tmp| (|String|)))
               (SEQ (LETT |tmp| (|TMFORM;formatExpr| |expr| |prec| %))
                    (COND ((OR (EQUAL |tmp| "") (EQUAL |tmp| " ")) (EXIT "")))
                    (EXIT
                     (SPADCALL (LIST "(" |s| " " |tmp| ")") (QREFELT % 41)))))) 

(SDEFUN |TMFORM;group| ((|str| (|String|)) (% (|String|)))
        (SPADCALL (LIST "(concat " |str| ")") (QREFELT % 41))) 

(SDEFUN |TMFORM;cork| ((|x| (|SingleInteger|)) (% (|String|)))
        (SPROG ((|s| (|String|)) (|res| (|Union| (|String|) "failed")))
               (SEQ (LETT |res| (SPADCALL |x| (QREFELT % 10) (QREFELT % 44)))
                    (EXIT
                     (COND
                      ((QEQCAR |res| 1)
                       (COND
                        ((SPADCALL |x| 1000 (QREFELT % 46))
                         (SEQ (LETT |s| (SPADCALL |x| 16 (QREFELT % 48)))
                              (EXIT
                               (SPADCALL (LIST "\\<#" |s| "\\>")
                                         (QREFELT % 41)))))
                        (#1='T (NUM2USTR |x|))))
                      (#1# (QCDR |res|))))))) 

(SDEFUN |TMFORM;utf2cork| ((|str| (|String|)) (% (|String|)))
        (SPROG ((#1=#:G117 NIL) (|i| NIL) (#2=#:G116 NIL))
               (SEQ
                (SPADCALL
                 (PROGN
                  (LETT #2# NIL)
                  (SEQ (LETT |i| NIL) (LETT #1# (UENTRIES |str|)) G190
                       (COND
                        ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#)) NIL))
                         (GO G191)))
                       (SEQ (EXIT (LETT #2# (CONS (|TMFORM;cork| |i| %) #2#))))
                       (LETT #1# (CDR #1#)) (GO G190) G191
                       (EXIT (NREVERSE #2#))))
                 (QREFELT % 41))))) 

(SDEFUN |TMFORM;addBraces| ((|str| (|String|)) (% (|String|)))
        (SPADCALL (LIST " \"{\" " |str| " \"}\" ") (QREFELT % 41))) 

(SDEFUN |TMFORM;addBrackets| ((|str| (|String|)) (% (|String|)))
        (SPADCALL (LIST " \"[\" " |str| " \"]\" ") (QREFELT % 41))) 

(SDEFUN |TMFORM;parenthesize| ((|str| (|String|)) (% (|String|)))
        (SPADCALL (LIST " \"(\" " |str| " \")\" ") (QREFELT % 41))) 

(SDEFUN |TMFORM;formatSpecial|
        ((|op| (|Symbol|)) (|args| (|List| (|OutputForm|)))
         (|prec| (|Integer|)) (% (|String|)))
        (SPROG ((|tmp| (|String|)) (|base| (|String|)))
               (SEQ
                (COND ((EQUAL |op| '|theMap|) "(concat \"theMap(...)\")")
                      ((EQUAL |op| 'AGGLST)
                       (|TMFORM;formatNary| '|,| "" 0 |args| |prec| %))
                      ((EQUAL |op| 'AGGSET)
                       (|TMFORM;formatNary| '|;| "" 0 |args| |prec| %))
                      ((EQUAL |op| '~>)
                       (|TMFORM;group|
                        (SPADCALL
                         (LIST
                          (|TMFORM;formatExpr| (|SPADfirst| |args|) |prec| %)
                          " \"<rightsquigarrow>\" "
                          (|TMFORM;formatExpr| (SPADCALL |args| (QREFELT % 50))
                           |prec| %))
                         (QREFELT % 41))
                        %))
                      (#1='T
                       (COND
                        ((EQUAL |op| 'SLASH)
                         (|TMFORM;group|
                          (SPADCALL
                           (LIST
                            (|TMFORM;formatExpr| (|SPADfirst| |args|) |prec| %)
                            " \"/\" "
                            (|TMFORM;formatExpr|
                             (SPADCALL |args| (QREFELT % 50)) |prec| %))
                           (QREFELT % 41))
                          %))
                        ((EQUAL |op| 'CONCATB)
                         (|TMFORM;formatNary| 'STRSEP "(space \"1spc\")" 0
                          |args| |prec| %))
                        ((EQUAL |op| 'CONCAT)
                         (|TMFORM;formatNary| 'STRSEP "" 0 |args|
                          (QREFELT % 13) %))
                        ((EQUAL |op| 'QUOTE)
                         (|TMFORM;group|
                          (STRCONC "'"
                                   (|TMFORM;formatExpr| (|SPADfirst| |args|)
                                    (QREFELT % 13) %))
                          %))
                        ((EQUAL |op| 'BRACKET)
                         (|TMFORM;group|
                          (|TMFORM;addBrackets|
                           (|TMFORM;ungroup|
                            (|TMFORM;formatExpr| (|SPADfirst| |args|)
                             (QREFELT % 13) %)
                            %)
                           %)
                          %))
                        ((EQUAL |op| 'BRACE)
                         (|TMFORM;group|
                          (|TMFORM;addBraces|
                           (|TMFORM;ungroup|
                            (|TMFORM;formatExpr| (|SPADfirst| |args|)
                             (QREFELT % 13) %)
                            %)
                           %)
                          %))
                        ((EQUAL |op| 'PAREN)
                         (|TMFORM;group|
                          (|TMFORM;parenthesize|
                           (|TMFORM;ungroup|
                            (|TMFORM;formatExpr| (|SPADfirst| |args|)
                             (QREFELT % 13) %)
                            %)
                           %)
                          %))
                        ((EQUAL |op| 'PRIME)
                         (|TMFORM;formatSpecial| 'SUPERSUB
                          (LIST (|SPADfirst| |args|) (SPADCALL (QREFELT % 51))
                                (SPADCALL |args| (QREFELT % 50)))
                          |prec| %))
                        ((EQUAL |op| 'OVERBAR)
                         (COND ((NULL |args|) "")
                               (#1#
                                (SPADCALL
                                 (LIST "(wide "
                                       (|TMFORM;formatExpr|
                                        (|SPADfirst| |args|) (QREFELT % 13) %)
                                       " \"<bar>\")")
                                 (QREFELT % 41)))))
                        ((EQUAL |op| 'ROOT)
                         (COND ((NULL |args|) "")
                               (#1#
                                (SEQ
                                 (LETT |tmp|
                                       (|TMFORM;group|
                                        (|TMFORM;formatExpr|
                                         (|SPADfirst| |args|) (QREFELT % 13) %)
                                        %))
                                 (EXIT
                                  (COND
                                   ((NULL (CDR |args|))
                                    (SPADCALL (LIST "(sqrt " |tmp| ")")
                                              (QREFELT % 41)))
                                   (#1#
                                    (SPADCALL
                                     (LIST "(sqrt " |tmp| " "
                                           (|TMFORM;formatExpr|
                                            (|SPADfirst| (CDR |args|))
                                            (QREFELT % 13) %)
                                           ")")
                                     (QREFELT % 41)))))))))
                        ((EQUAL |op| 'SEGMENT)
                         (SEQ
                          (LETT |tmp|
                                (SPADCALL
                                 (LIST
                                  (|TMFORM;formatExpr| (|SPADfirst| |args|)
                                   (QREFELT % 13) %)
                                  " \"..\" ")
                                 (QREFELT % 41)))
                          (EXIT
                           (|TMFORM;group|
                            (COND ((NULL (CDR |args|)) |tmp|)
                                  (#1#
                                   (SPADCALL
                                    (LIST |tmp|
                                          (|TMFORM;formatExpr|
                                           (|SPADfirst| (CDR |args|))
                                           (QREFELT % 13) %))
                                    (QREFELT % 41))))
                            %))))
                        ((EQUAL |op| 'SUB)
                         (|TMFORM;group|
                          (SPADCALL
                           (LIST "(concat "
                                 (|TMFORM;formatExpr| (|SPADfirst| |args|)
                                  (QREFELT % 13) %)
                                 "(rsub "
                                 (|TMFORM;formatSpecial| 'AGGLST (CDR |args|)
                                  (QREFELT % 13) %)
                                 "))")
                           (QREFELT % 41))
                          %))
                        ((EQUAL |op| 'SUPERSUB)
                         (SEQ
                          (LETT |base|
                                (|TMFORM;formatExpr| (|SPADfirst| |args|)
                                 (QREFELT % 13) %))
                          (LETT |args| (CDR |args|))
                          (EXIT
                           (COND
                            ((> (LENGTH |args|) 4)
                             (|error|
                              "multiscript object has more than 4 scripts"))
                            (#1#
                             (SEQ
                              (COND
                               ((NULL (NULL |args|))
                                (SEQ
                                 (LETT |base|
                                       (SPADCALL
                                        (LIST |base| " "
                                              (|TMFORM;optionalWrap| "rsub"
                                               (SPADCALL |args| 1
                                                         (QREFELT % 52))
                                               (QREFELT % 13) %))
                                        (QREFELT % 41)))
                                 (EXIT (LETT |args| (CDR |args|))))))
                              (COND
                               ((NULL (NULL |args|))
                                (SEQ
                                 (LETT |base|
                                       (SPADCALL
                                        (LIST |base| " "
                                              (|TMFORM;optionalWrap| "rsup"
                                               (SPADCALL |args| 1
                                                         (QREFELT % 52))
                                               (QREFELT % 13) %))
                                        (QREFELT % 41)))
                                 (EXIT (LETT |args| (CDR |args|))))))
                              (COND
                               ((NULL (NULL |args|))
                                (SEQ
                                 (LETT |base|
                                       (SPADCALL
                                        (LIST
                                         (|TMFORM;optionalWrap| "lsup"
                                          (SPADCALL |args| 1 (QREFELT % 52))
                                          (QREFELT % 13) %)
                                         " " |base|)
                                        (QREFELT % 41)))
                                 (EXIT (LETT |args| (CDR |args|))))))
                              (COND
                               ((NULL (NULL |args|))
                                (LETT |base|
                                      (SPADCALL
                                       (LIST
                                        (|TMFORM;optionalWrap| "lsub"
                                         (SPADCALL |args| 1 (QREFELT % 52))
                                         (QREFELT % 13) %)
                                        " " |base|)
                                       (QREFELT % 41)))))
                              (EXIT
                               (SPADCALL (LIST "(concat " |base| ")")
                                         (QREFELT % 41)))))))))
                        ((EQUAL |op| 'SC)
                         (COND ((NULL |args|) "")
                               (#1#
                                (SEQ
                                 (LETT |tmp|
                                       (|TMFORM;formatNaryNoGroup| 'STRSEP
                                        ")) (row (cell " 0 |args|
                                        (QREFELT % 13) %))
                                 (EXIT
                                  (SPADCALL
                                   (LIST
                                    "(tabular (tformat (twith \"table-valign\" \"t\") (table (row (cell "
                                    |tmp| ")))))")
                                   (QREFELT % 41)))))))
                        ((EQUAL |op| 'MATRIX)
                         (|TMFORM;formatMatrix| (CDR |args|) %))
                        ((EQUAL |op| 'BINOMIAL)
                         (SPADCALL
                          (LIST "(binom "
                                (|TMFORM;formatExpr|
                                 (SPADCALL |args| 1 (QREFELT % 52))
                                 (QREFELT % 13) %)
                                " "
                                (|TMFORM;formatExpr|
                                 (SPADCALL |args| 2 (QREFELT % 52))
                                 (QREFELT % 13) %)
                                ")")
                          (QREFELT % 41)))
                        ((EQUAL |op| 'NOTHING) "\"\"")
                        (#1#
                         (SPADCALL
                          (LIST "(concat \"not done yet for: "
                                (SPADCALL |op| (QREFELT % 54)) "\")")
                          (QREFELT % 41))))))))) 

(SDEFUN |TMFORM;formatPlex|
        ((|op| (|Symbol|)) (|args| (|List| (|OutputForm|)))
         (|prec| (|Integer|)) (% (|String|)))
        (SPROG
         ((|s| (|String|)) (|t1| #1=(|String|)) (|t2| (|String|)) (|body| #1#)
          (|ops| (|String|)) (|n| (|Integer|)) (|opPrec| (|Integer|))
          (|p| (|Integer|)))
         (SEQ (LETT |p| (SPADCALL |op| (QREFELT % 21) (QREFELT % 56)))
              (EXIT
               (COND ((< |p| 1) (|error| "unknown plex op"))
                     (#2='T
                      (SEQ
                       (LETT |opPrec|
                             (SPADCALL (QREFELT % 22) |p| (QREFELT % 58)))
                       (LETT |n| (LENGTH |args|))
                       (COND
                        ((SPADCALL |n| 2 (QREFELT % 59))
                         (COND
                          ((SPADCALL |n| 3 (QREFELT % 59))
                           (EXIT
                            (|error| "wrong number of arguments for plex"))))))
                       (LETT |ops|
                             (COND
                              ((EQUAL |op| 'SIGMA)
                               (COND ((EQL |n| 2) "<sum>")
                                     (#2#
                                      (|error|
                                       "wrong number of arguments for plex"))))
                              ((EQUAL |op| 'SIGMA2)
                               (COND ((EQL |n| 3) "<sum>")
                                     (#2#
                                      (|error|
                                       "wrong number of arguments for plex"))))
                              ((EQUAL |op| 'PI)
                               (COND ((EQL |n| 2) "<prod>")
                                     (#2#
                                      (|error|
                                       "wrong number of arguments for plex"))))
                              ((EQUAL |op| 'PI2)
                               (COND ((EQL |n| 3) "<prod>")
                                     (#2#
                                      (|error|
                                       "wrong number of arguments for plex"))))
                              ((EQUAL |op| 'INTSIGN)
                               (COND ((EQL |n| 3) "<int>")
                                     (#2#
                                      (|error|
                                       "wrong number of arguments for plex"))))
                              (#2#
                               (|error|
                                (SPADCALL "Unexpected plex op:"
                                          (SPADCALL |op| (QREFELT % 54))
                                          (QREFELT % 60))))))
                       (LETT |body|
                             (COND
                              ((EQUAL |op| 'INTSIGN)
                               (STRCONC
                                (|TMFORM;formatIntBody|
                                 (SPADCALL |args| 3 (QREFELT % 52))
                                 (QREFELT % 13) %)
                                " (big \".\")"))
                              (#2#
                               (|TMFORM;formatExpr|
                                (SPADCALL |args| |n| (QREFELT % 52)) |opPrec|
                                %))))
                       (LETT |t2|
                             (COND
                              ((EQL |n| 3)
                               (SPADCALL
                                (LIST " (rsup "
                                      (|TMFORM;formatExpr|
                                       (SPADCALL |args| 2 (QREFELT % 52))
                                       (QREFELT % 13) %)
                                      ")")
                                (QREFELT % 41)))
                              (#2# "")))
                       (LETT |t1|
                             (|TMFORM;formatExpr|
                              (SPADCALL |args| 1 (QREFELT % 52)) (QREFELT % 13)
                              %))
                       (LETT |s|
                             (SPADCALL
                              (LIST "(big-around \"" |ops| "\" (concat (rsub "
                                    |t1| ")" |t2| " " |body| "))")
                              (QREFELT % 41)))
                       (COND
                        ((< |opPrec| |prec|)
                         (LETT |s| (|TMFORM;parenthesize| |s| %))))
                       (EXIT |s|)))))))) 

(SDEFUN |TMFORM;formatIntBody|
        ((|body| (|OutputForm|)) (|opPrec| (|Integer|)) (% (|String|)))
        (SPROG
         ((#1=#:G193 NIL) (|bvarS| (|String|))
          (|bvarL| #2=(|List| (|OutputForm|))) (|bvar| (|OutputForm|))
          (|bodyL| #2#))
         (SEQ
          (EXIT
           (SEQ
            (COND
             ((SPADCALL |body| '* (QREFELT % 61))
              (SEQ (LETT |bodyL| (SPADCALL |body| (QREFELT % 62)))
                   (EXIT
                    (COND
                     ((EQL (LENGTH |bodyL|) 2)
                      (COND
                       ((SPADCALL
                         (LETT |bvar| (SPADCALL |bodyL| 2 (QREFELT % 52)))
                         'CONCAT (QREFELT % 61))
                        (SEQ (LETT |bvarL| (SPADCALL |bvar| (QREFELT % 62)))
                             (EXIT
                              (COND
                               ((EQL (LENGTH |bvarL|) 2)
                                (COND
                                 ((SPADCALL (SPADCALL |bvarL| 1 (QREFELT % 52))
                                            '|d| (QREFELT % 63))
                                  (COND
                                   ((SPADCALL
                                     (SPADCALL |bvarL| 2 (QREFELT % 52))
                                     (QREFELT % 64))
                                    (SEQ
                                     (LETT |bvarS|
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |bvarL| 2
                                                       (QREFELT % 52))
                                             (QREFELT % 65))
                                            (QREFELT % 54)))
                                     (EXIT
                                      (PROGN
                                       (LETT #1#
                                             (SPADCALL
                                              (LIST "(concat "
                                                    (|TMFORM;formatExpr|
                                                     (SPADCALL |bodyL| 1
                                                               (QREFELT % 52))
                                                     |opPrec| %)
                                                    " \"*<mathd>" |bvarS|
                                                    "\")")
                                              (QREFELT % 41)))
                                       (GO #3=#:G192))))))))))))))))))))
            (EXIT (|TMFORM;formatExpr| |body| |opPrec| %))))
          #3# (EXIT #1#)))) 

(SDEFUN |TMFORM;formatMatrix| ((|args| (|List| (|OutputForm|))) (% (|String|)))
        (|TMFORM;group|
         (SPADCALL
          (LIST "(matrix (tformat (table (row (cell "
                (|TMFORM;formatNaryNoGroup| 'STRSEP ")) (row (cell " 0 |args|
                 (QREFELT % 13) %)
                ")))))")
          (QREFELT % 41))
         %)) 

(SDEFUN |TMFORM;formatFunction|
        ((|op| (|OutputForm|)) (|args| (|List| (|OutputForm|)))
         (|prec| (|Integer|)) (% (|String|)))
        (SPROG ((|ops| (|String|)))
               (SEQ (LETT |ops| (|TMFORM;formatExpr| |op| (QREFELT % 13) %))
                    (EXIT
                     (|TMFORM;group|
                      (SPADCALL
                       (LIST |ops| " "
                             (|TMFORM;parenthesize|
                              (|TMFORM;formatNary| '|,| "" 0 |args|
                               (QREFELT % 13) %)
                              %))
                       (QREFELT % 41))
                      %))))) 

(SDEFUN |TMFORM;formatNullary| ((|op| (|Symbol|)) (% (|String|)))
        (COND ((EQUAL |op| 'NOTHING) "\"\"")
              ('T
               (|TMFORM;group|
                (SPADCALL (LIST "\"" (SPADCALL |op| (QREFELT % 54)) "()\"")
                          (QREFELT % 41))
                %)))) 

(SDEFUN |TMFORM;formatUnary|
        ((|op| (|Symbol|)) (|arg| (|OutputForm|)) (|prec| (|Integer|))
         (% (|String|)))
        (SPROG ((|s| (|String|)) (|opPrec| (|Integer|)) (|p| (|Integer|)))
               (SEQ (LETT |p| (SPADCALL |op| (QREFELT % 14) (QREFELT % 56)))
                    (EXIT
                     (COND ((< |p| 1) (|error| "unknown unary op"))
                           (#1='T
                            (SEQ
                             (LETT |opPrec|
                                   (SPADCALL (QREFELT % 15) |p|
                                             (QREFELT % 58)))
                             (LETT |s|
                                   (SPADCALL
                                    (LIST "(concat \""
                                          (SPADCALL |op| (QREFELT % 54)) "\" "
                                          (|TMFORM;formatExpr| |arg| |opPrec|
                                           %)
                                          ")")
                                    (QREFELT % 41)))
                             (EXIT
                              (COND
                               ((< |opPrec| |prec|)
                                (|TMFORM;group| (|TMFORM;parenthesize| |s| %)
                                 %))
                               ((EQUAL |op| '-) |s|)
                               (#1# (|TMFORM;group| |s| %))))))))))) 

(SDEFUN |TMFORM;formatBinary|
        ((|op| (|Symbol|)) (|args| (|List| (|OutputForm|)))
         (|prec| (|Integer|)) (% (|String|)))
        (SPROG
         ((|s| (|String|)) (|ops| (|String|)) (|s2| #1=(|String|)) (|s1| #1#)
          (|opPrec| (|Integer|)) (|p| (|Integer|)))
         (SEQ (LETT |p| (SPADCALL |op| (QREFELT % 16) (QREFELT % 56)))
              (EXIT
               (COND ((< |p| 1) (|error| "unknown binary op"))
                     (#2='T
                      (SEQ
                       (LETT |opPrec|
                             (SPADCALL (QREFELT % 17) |p| (QREFELT % 58)))
                       (LETT |s1|
                             (|TMFORM;formatExpr| (|SPADfirst| |args|) |opPrec|
                              %))
                       (LETT |s2|
                             (|TMFORM;formatExpr| (|SPADfirst| (CDR |args|))
                              |opPrec| %))
                       (LETT |s|
                             (COND
                              ((EQUAL |op| '^)
                               (SPADCALL
                                (LIST
                                 (SPADCALL "(concat "
                                           (SPADCALL |s1|
                                                     (SPADCALL "(rsup "
                                                               (SPADCALL |s2|
                                                                         "))"
                                                                         (QREFELT
                                                                          %
                                                                          60))
                                                               (QREFELT % 60))
                                                     (QREFELT % 60))
                                           (QREFELT % 60)))
                                (QREFELT % 41)))
                              ((EQUAL |op| '/)
                               (SPADCALL (LIST "(frac " |s1| " " |s2| ")")
                                         (QREFELT % 41)))
                              (#2#
                               (COND
                                ((EQUAL |op| 'OVER)
                                 (SPADCALL (LIST "(frac " |s1| " " |s2| ")")
                                           (QREFELT % 41)))
                                (#2#
                                 (SEQ
                                  (LETT |ops|
                                        (COND ((EQUAL |op| '~=) "<ne>")
                                              ((EQUAL |op| '<) "<less>")
                                              ((EQUAL |op| '<=) "<leq>")
                                              ((EQUAL |op| '>) "<gtr>")
                                              ((EQUAL |op| '>=) "<geq>")
                                              ((EQUAL |op| '+->) "<mapsto>")
                                              ((EQUAL |op| '->) "<rightarrow>")
                                              (#2#
                                               (COND ((EQUAL |op| 'LET) ":=")
                                                     (#2#
                                                      (SPADCALL |op|
                                                                (QREFELT %
                                                                         54)))))))
                                  (EXIT
                                   (SPADCALL
                                    (LIST "(concat " |s1| " \"" |ops| "\" "
                                          |s2| ")")
                                    (QREFELT % 41)))))))))
                       (EXIT
                        (|TMFORM;group|
                         (COND
                          ((OR (OR (EQUAL |op| '/) (EQUAL |op| 'OVER))
                               (NULL (< |opPrec| |prec|)))
                           |s|)
                          ('T (|TMFORM;parenthesize| |s| %)))
                         %))))))))) 

(SDEFUN |TMFORM;formatNary|
        ((|op| (|Symbol|)) (|sep| (|String|)) (|opprec| (|Integer|))
         (|args| (|List| (|OutputForm|))) (|prec| (|Integer|)) (% (|String|)))
        (|TMFORM;group|
         (|TMFORM;formatNaryNoGroup| |op| |sep| |opprec| |args| |prec| %) %)) 

(SDEFUN |TMFORM;formatNaryNoGroup|
        ((|op| (|Symbol|)) (|sep| (|String|)) (|opprec| (|Integer|))
         (|args| (|List| (|OutputForm|))) (|prec| (|Integer|)) (% (|String|)))
        (SPROG
         ((|s| (|String|)) (|l| (|List| (|String|))) (#1=#:G225 NIL) (|a| NIL)
          (|opPrec| (|Integer|)) (|ops| (|String|)) (|p| (|Integer|)))
         (SEQ
          (COND ((NULL |args|) "")
                (#2='T
                 (SEQ (LETT |p| (SPADCALL |op| (QREFELT % 18) (QREFELT % 56)))
                      (EXIT
                       (COND ((< |p| 1) (|error| "unknown nary op"))
                             (#2#
                              (SEQ
                               (COND
                                ((> (LENGTH |args|) 1)
                                 (COND
                                  ((SPADCALL (SPADCALL |args| 2 (QREFELT % 52))
                                             'ZAG (QREFELT % 61))
                                   (EXIT
                                    (COND
                                     ((SPADCALL |op| '+ (QREFELT % 66))
                                      (|error| "ZAG in unexpected place"))
                                     ((SPADCALL
                                       (SPADCALL |args| 1 (QREFELT % 52)) 'ZAG
                                       (QREFELT % 61))
                                      (|TMFORM;formatZag| |args| %))
                                     (#2#
                                      (SPADCALL
                                       (LIST
                                        (|TMFORM;formatExpr|
                                         (|SPADfirst| |args|) (QREFELT % 13) %)
                                        " \"+\" "
                                        (|TMFORM;formatZag| (CDR |args|) %))
                                       (QREFELT % 41)))))))))
                               (LETT |ops|
                                     (COND ((EQUAL |op| 'STRSEP) |sep|)
                                           ((EQUAL |op| 'ROW) ") (cell ")
                                           ((EQUAL |op| 'TENSOR)
                                            " \"<otimes>\" ")
                                           (#2#
                                            (SPADCALL
                                             (LIST " \""
                                                   (SPADCALL |op|
                                                             (QREFELT % 54))
                                                   "\" ")
                                             (QREFELT % 41)))))
                               (LETT |l| NIL)
                               (LETT |opPrec|
                                     (COND ((EQUAL |op| 'STRSEP) |opprec|)
                                           (#2#
                                            (SPADCALL (QREFELT % 19) |p|
                                                      (QREFELT % 58)))))
                               (SEQ (LETT |a| NIL) (LETT #1# |args|) G190
                                    (COND
                                     ((OR (ATOM #1#)
                                          (PROGN (LETT |a| (CAR #1#)) NIL))
                                      (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT |l|
                                            (CONS |ops|
                                                  (CONS
                                                   (|TMFORM;formatExpr| |a|
                                                    |opPrec| %)
                                                   |l|)))))
                                    (LETT #1# (CDR #1#)) (GO G190) G191
                                    (EXIT NIL))
                               (LETT |s|
                                     (SPADCALL (REVERSE (CDR |l|))
                                               (QREFELT % 41)))
                               (EXIT
                                (COND
                                 ((< |opPrec| |prec|)
                                  (|TMFORM;parenthesize| |s| %))
                                 (#2# |s|))))))))))))) 

(SDEFUN |TMFORM;formatZag| ((|args| (|List| (|OutputForm|))) (% (|String|)))
        (SPROG ((|tmpZag| (|List| (|OutputForm|))))
               (SEQ
                (COND
                 ((SPADCALL (|SPADfirst| |args|) '|...| (QREFELT % 63))
                  "<ldots>")
                 ((NULL (SPADCALL (|SPADfirst| |args|) 'ZAG (QREFELT % 61)))
                  (|error|
                   (SPADCALL "formatZag: Last argument in ZAG construct "
                             "has unknown operator" (QREFELT % 60))))
                 ('T
                  (SEQ
                   (LETT |tmpZag|
                         (SPADCALL (|SPADfirst| |args|) (QREFELT % 62)))
                   (EXIT
                    (COND
                     ((> (LENGTH |args|) 1)
                      (SPADCALL "(frac "
                                (SPADCALL
                                 (|TMFORM;formatExpr| (|SPADfirst| |tmpZag|)
                                  (QREFELT % 13) %)
                                 (SPADCALL "(concat "
                                           (SPADCALL
                                            (|TMFORM;formatExpr|
                                             (|SPADfirst| (CDR |tmpZag|))
                                             (QREFELT % 13) %)
                                            (SPADCALL " \"+\" "
                                                      (SPADCALL
                                                       (|TMFORM;formatZag|
                                                        (CDR |args|) %)
                                                       "))" (QREFELT % 60))
                                                      (QREFELT % 60))
                                            (QREFELT % 60))
                                           (QREFELT % 60))
                                 (QREFELT % 60))
                                (QREFELT % 60)))
                     ('T
                      (SPADCALL "(frac "
                                (SPADCALL
                                 (|TMFORM;formatExpr| (|SPADfirst| |tmpZag|)
                                  (QREFELT % 13) %)
                                 (SPADCALL
                                  (|TMFORM;formatExpr|
                                   (|SPADfirst| (CDR |tmpZag|)) (QREFELT % 13)
                                   %)
                                  ")" (QREFELT % 60))
                                 (QREFELT % 60))
                                (QREFELT % 60))))))))))) 

(SDEFUN |TMFORM;formatExpr|
        ((|expr| (|OutputForm|)) (|prec| (|Integer|)) (% (|String|)))
        (SPROG
         ((|op| #1=(|Symbol|)) (|nargs| (|Integer|))
          (|args| (|List| (|OutputForm|))) (|opf| (|OutputForm|))
          (|i| (|Integer|)) (|len| (|Integer|)) (|str| (|String|))
          (#2=#:G264 NIL) (|es| #1#) (|nstr| (|String|))
          (|intSplitLen| (|Integer|)))
         (SEQ
          (EXIT
           (SEQ (LETT |intSplitLen| 20)
                (EXIT
                 (COND
                  ((SPADCALL |expr| (QREFELT % 67))
                   (COND
                    ((SPADCALL |expr| (QREFELT % 68))
                     (SEQ (LETT |i| (SPADCALL |expr| (QREFELT % 69)))
                          (LETT |str| (STRINGIMAGE |i|))
                          (EXIT
                           (COND
                            ((OR (< |i| 0) (> |i| 9))
                             (|TMFORM;group|
                              (SEQ (LETT |nstr| "")
                                   (SEQ G190
                                        (COND
                                         ((NULL
                                           (> (LETT |len| (QCSIZE |str|))
                                              |intSplitLen|))
                                          (GO G191)))
                                        (SEQ
                                         (LETT |nstr|
                                               (SPADCALL
                                                (LIST |nstr| " "
                                                      (SPADCALL |str|
                                                                (SPADCALL 1
                                                                          |intSplitLen|
                                                                          (QREFELT
                                                                           %
                                                                           38))
                                                                (QREFELT %
                                                                         39)))
                                                (QREFELT % 41)))
                                         (EXIT
                                          (LETT |str|
                                                (SPADCALL |str|
                                                          (SPADCALL
                                                           (+ |intSplitLen| 1)
                                                           (QREFELT % 70))
                                                          (QREFELT % 39)))))
                                        NIL (GO G190) G191 (EXIT NIL))
                                   (EXIT
                                    (COND
                                     ((SPADCALL |nstr| (QREFELT % 71))
                                      (SPADCALL (LIST " \"" |str| "\" ")
                                                (QREFELT % 41)))
                                     (#3='T
                                      (SEQ
                                       (LETT |nstr|
                                             (COND
                                              ((SPADCALL |str| (QREFELT % 71))
                                               |nstr|)
                                              (#3#
                                               (SPADCALL
                                                (LIST |nstr| " " |str|)
                                                (QREFELT % 41)))))
                                       (EXIT
                                        (SPADCALL
                                         (LIST
                                          (SPADCALL |nstr|
                                                    (SPADCALL 2 (QREFELT % 70))
                                                    (QREFELT % 39)))
                                         (QREFELT % 41))))))))
                              %))
                            ('T
                             (SPADCALL (LIST " \"" |str| "\" ")
                                       (QREFELT % 41)))))))
                    (#3#
                     (SEQ
                      (COND
                       ((SPADCALL |expr| (QREFELT % 64))
                        (SEQ (LETT |es| (SPADCALL |expr| (QREFELT % 65)))
                             (EXIT
                              (COND
                               ((EQUAL |es| '|%pi|)
                                (PROGN (LETT #2# "<mathpi>") (GO #4=#:G263)))
                               ((EQUAL |es| '|%e|)
                                (PROGN (LETT #2# "<mathe>") (GO #4#)))
                               ((EQUAL |es| '|%i|)
                                (PROGN (LETT #2# "<mathi>") (GO #4#)))
                               (#3#
                                (COND
                                 ((EQUAL |es| '|infinity|)
                                  (PROGN (LETT #2# "<infty>") (GO #4#)))
                                 (#3#
                                  (LETT |str|
                                        (SPADCALL |es| (QREFELT % 54))))))))))
                       ((SPADCALL |expr| (QREFELT % 72))
                        (LETT |str| (SPADCALL |expr| (QREFELT % 73))))
                       (#3# (|error| "Unrecognized atom in OutputForm")))
                      (LETT |len| (QCSIZE |str|))
                      (COND
                       ((> |len| 0)
                        (COND
                         ((|eql_SI| (SPADCALL |str| 1 (QREFELT % 75))
                                    (|STR_to_CHAR| "%"))
                          (EXIT
                           (SPADCALL (LIST " \"" |str| "\" ")
                                     (QREFELT % 41)))))))
                      (COND
                       ((> |len| 0)
                        (COND
                         ((|eql_SI| (SPADCALL |str| 1 (QREFELT % 75))
                                    (|STR_to_CHAR| "\""))
                          (EXIT
                           (SPADCALL
                            (LIST "(text (concat " "\"\\\"\" "
                                  (SPADCALL
                                   (LIST "(math " (|TMFORM;utf2cork| |str| %)
                                         ")")
                                   (QREFELT % 41))
                                  " \"\\\"\") )")
                            (QREFELT % 41)))))))
                      (COND
                       ((EQL |len| 1)
                        (COND
                         ((|eql_SI| (SPADCALL |str| 1 (QREFELT % 75))
                                    (|STR_to_CHAR| " "))
                          (EXIT " ")))))
                      (COND
                       ((SPADCALL |expr| (QREFELT % 64))
                        (SEQ (LETT |op| (SPADCALL |expr| (QREFELT % 65)))
                             (LETT |i|
                                   (SPADCALL |op| (QREFELT % 24)
                                             (QREFELT % 56)))
                             (EXIT
                              (COND
                               ((> |i| 0)
                                (SPADCALL (QREFELT % 25) |i|
                                          (QREFELT % 77))))))))
                      (LETT |i|
                            (SPADCALL (|STR_to_CHAR| " ") |str|
                                      (QREFELT % 79)))
                      (EXIT
                       (COND
                        ((> |i| 0)
                         (SPADCALL (LIST " \"" |str| "\" ") (QREFELT % 41)))
                        (#3#
                         (|TMFORM;group|
                          (|TMFORM;utf2cork|
                           (SPADCALL (LIST " \"" |str| "\" ") (QREFELT % 41))
                           %)
                          %))))))))
                  (#3#
                   (SEQ (LETT |opf| (SPADCALL |expr| (QREFELT % 80)))
                        (LETT |args| (SPADCALL |expr| (QREFELT % 62)))
                        (LETT |nargs| (LENGTH |args|))
                        (EXIT
                         (COND
                          ((SPADCALL |opf| (QREFELT % 64))
                           (SEQ (LETT |op| (SPADCALL |opf| (QREFELT % 65)))
                                (EXIT
                                 (COND
                                  ((SPADCALL |op| (QREFELT % 23)
                                             (QREFELT % 81))
                                   (|TMFORM;formatSpecial| |op| |args| |prec|
                                    %))
                                  ((SPADCALL |op| (QREFELT % 21)
                                             (QREFELT % 81))
                                   (|TMFORM;formatPlex| |op| |args| |prec| %))
                                  ((EQL 0 |nargs|)
                                   (|TMFORM;formatNullary| |op| %))
                                  (#3#
                                   (SEQ
                                    (COND
                                     ((EQL 1 |nargs|)
                                      (COND
                                       ((SPADCALL |op| (QREFELT % 14)
                                                  (QREFELT % 81))
                                        (EXIT
                                         (|TMFORM;formatUnary| |op|
                                          (|SPADfirst| |args|) |prec| %))))))
                                    (COND
                                     ((EQL 2 |nargs|)
                                      (COND
                                       ((SPADCALL |op| (QREFELT % 16)
                                                  (QREFELT % 81))
                                        (EXIT
                                         (|TMFORM;formatBinary| |op| |args|
                                          |prec| %))))))
                                    (EXIT
                                     (COND
                                      ((SPADCALL |op| (QREFELT % 20)
                                                 (QREFELT % 81))
                                       (|TMFORM;formatNaryNoGroup| |op| "" 0
                                        |args| |prec| %))
                                      ((SPADCALL |op| (QREFELT % 18)
                                                 (QREFELT % 81))
                                       (|TMFORM;formatNary| |op| "" 0 |args|
                                        |prec| %))
                                      (#3#
                                       (|TMFORM;formatFunction| |opf| |args|
                                        |prec| %))))))))))
                          (#3#
                           (|TMFORM;formatFunction| |opf| |args| |prec|
                            %))))))))))
          #4# (EXIT #2#)))) 

(DECLAIM (NOTINLINE |TexmacsFormat;|)) 

(DEFUN |TexmacsFormat| ()
  (SPROG NIL
         (PROG (#1=#:G266)
           (RETURN
            (COND
             ((LETT #1# (HGET |$ConstructorCache| '|TexmacsFormat|))
              (|CDRwithIncrement| (CDAR #1#)))
             ('T
              (UNWIND-PROTECT
                  (PROG1
                      (CDDAR
                       (HPUT |$ConstructorCache| '|TexmacsFormat|
                             (LIST (CONS NIL (CONS 1 (|TexmacsFormat;|))))))
                    (LETT #1# T))
                (COND
                 ((NOT #1#) (HREM |$ConstructorCache| '|TexmacsFormat|)))))))))) 

(DEFUN |TexmacsFormat;| ()
  (SPROG ((|dv$| NIL) (% NIL) (|pv$| NIL))
         (PROGN
          (LETT |dv$| '(|TexmacsFormat|))
          (LETT % (GETREFV 82))
          (QSETREFV % 0 |dv$|)
          (QSETREFV % 3 (LETT |pv$| (|buildPredVector| 0 0 NIL)))
          (|haddProp| |$ConstructorCache| '|TexmacsFormat| NIL (CONS 1 %))
          (|stuffDomainSlots| %)
          (SETF |pv$| (QREFELT % 3))
          (QSETREFV % 10 (|TMFORM;CorkFunc| %))
          (QSETREFV % 11 " \\  ")
          (QSETREFV % 12 1000000)
          (QSETREFV % 13 0)
          (QSETREFV % 14 '(-))
          (QSETREFV % 15 '(710))
          (QSETREFV % 16 '(+-> |\|| ^ / = ~= < <= > >= OVER LET ->))
          (QSETREFV % 17
                    (LIST 0 0 900 700 400 400 400 400 400 400 700 125 1001))
          (QSETREFV % 18 '(- + * |,| |;| ROW STRSEP TENSOR))
          (QSETREFV % 19 (LIST 700 700 800 110 110 0 0 850))
          (QSETREFV % 20 '(ROW))
          (QSETREFV % 21 '(SIGMA SIGMA2 PI PI2 INTSIGN))
          (QSETREFV % 22 '(750 750 750 750 700))
          (QSETREFV % 23
                    '(MATRIX BRACKET BRACE CONCATB VCONCAT AGGLST CONCAT
                      OVERBAR ROOT SUB ~> SUPERSUB ZAG AGGSET SC PAREN SEGMENT
                      QUOTE |theMap| SLASH PRIME BOX EQUATNUM BINOMIAL
                      NOTHING))
          (QSETREFV % 24
                    '(|cos| |cot| |csc| |log| |sec| |sin| |tan| |cosh| |coth|
                      |csch| |sech| |sinh| |tanh| |acos| |asin| |atan| |erf|
                      |...| $ |infinity| |Gamma|))
          (QSETREFV % 25
                    (LIST "\"cos\"" "\"cot\"" "\"csc\"" "\"log\"" "\"sec\""
                          "\"sin\"" "\"tan\"" "\"cosh\"" "\"coth\"" "\"csch\""
                          "\"sech\"" "\"sinh\"" "\"tanh\"" "\"arccos\""
                          "\"arcsin\"" "\"arctan\"" "\"erf\"" "\"<cdots>\""
                          "\"$\"" "\"<infty>\"" "\"<Gamma>\""))
          %))) 

(MAKEPROP '|TexmacsFormat| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL
              (|Record| (|:| |key| 43) (|:| |entry| 29)) (|List| 6)
              (|HashTable| 43 29 '"EQ") (0 . |construct|) '|Cork| '|blank|
              '|maxPrec| '|minPrec| '|unaryOps| '|unaryPrecs| '|binaryOps|
              '|binaryPrecs| '|naryOps| '|naryPrecs| '|naryNGOps| '|plexOps|
              '|plexPrecs| '|specialOps| '|specialStrings|
              '|specialStringsInMML| (|OutputForm|) (|OutputFormTools|)
              (5 . |precondition|) (|String|) |TMFORM;coerce;OfS;2|
              |TMFORM;coerceL;OfS;4| (|Void|) (10 . |void|)
              |TMFORM;display;SV;5| (|Integer|) (14 . |position|)
              (|UniversalSegment| 35) (21 . |segment|) (27 . |elt|) (|List| %)
              (33 . |concat|) (|Union| 29 '"failed") (|SingleInteger|)
              (38 . |search|) (|Boolean|) (44 . >) (|NumberFormats|)
              (50 . |FormatRadix|) (|List| 26) (56 . |second|) (61 . |empty|)
              (65 . |elt|) (|Symbol|) (71 . |string|) (|List| 53)
              (76 . |position|) (|List| 35) (82 . |elt|) (88 . ~=) (94 . |elt|)
              (100 . |has_op?|) (106 . |arguments|) (111 . |is_symbol?|)
              (117 . |symbol?|) (122 . |symbol|) (127 . ~=) (133 . |atom?|)
              (138 . |integer?|) (143 . |integer|) (148 . |segment|)
              (153 . |empty?|) (158 . |string?|) (163 . |string|) (|Character|)
              (168 . |elt|) (|List| 29) (174 . |elt|) (180 . |char|)
              (185 . |position|) (191 . |operator|) (196 . |member?|))
           '#(~= 202 |latex| 208 |display| 213 |coerceL| 218 |coerce| 223 =
              233)
           'NIL
           (CONS (|makeByteWordVec2| 1 '(0 0 0))
                 (CONS '#(|SetCategory&| NIL |BasicType&|)
                       (CONS
                        '#((|SetCategory|) (|CoercibleTo| 26) (|BasicType|))
                        (|makeByteWordVec2| 81
                                            '(1 8 0 7 9 1 27 26 26 28 0 32 0 33
                                              3 29 35 0 0 35 36 2 37 0 35 35 38
                                              2 29 0 0 37 39 1 29 0 40 41 2 8
                                              42 43 0 44 2 43 45 0 0 46 2 47 29
                                              35 35 48 1 49 26 0 50 0 26 0 51 2
                                              49 26 0 35 52 1 53 29 0 54 2 55
                                              35 53 0 56 2 57 35 0 35 58 2 35
                                              45 0 0 59 2 29 0 0 0 60 2 27 45
                                              26 53 61 1 27 49 26 62 2 27 45 26
                                              53 63 1 27 45 26 64 1 27 53 26 65
                                              2 53 45 0 0 66 1 27 45 26 67 1 27
                                              45 26 68 1 27 35 26 69 1 37 0 35
                                              70 1 29 45 0 71 1 27 45 26 72 1
                                              27 29 26 73 2 29 74 0 35 75 2 76
                                              29 0 35 77 1 74 0 29 78 2 29 35
                                              74 0 79 1 27 26 26 80 2 55 45 53
                                              0 81 2 0 45 0 0 1 1 0 29 0 1 1 0
                                              32 29 34 1 0 29 26 31 1 0 26 0 1
                                              1 0 29 26 30 2 0 45 0 0 1)))))
           '|lookupComplete|)) 
