home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / texsrc.arc / TEX8.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  56KB  |  2,235 lines
  1. overlay "tex8"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5. mathlimitswi () { /* 10 */ r_mathlimitswi 
  6.   if ( curlist .headfield != curlist .tailfield ) 
  7.   if ( mem [(long) curlist .tailfield ] .hh.b0 == 17 ) 
  8.   {
  9.     mem [(long) curlist .tailfield ] .hh.b1 = curchr ; 
  10.     return ; 
  11.   } 
  12.   {
  13.     if ( interaction == 3 ) 
  14.     wakeuptermin () ; 
  15.     printnl ( 133 ) ; 
  16.     print ( 978 ) ; 
  17.   } 
  18.   {
  19.     helpptr = 1 ; 
  20.     helpline [ 0 ] = 979 ; 
  21.   } 
  22.   error () ; 
  23. } 
  24. zscandelimite ( p , r ) 
  25. halfword p ; 
  26. boolean r ; 
  27. {r_scandelimite 
  28.   if ( r ) 
  29.   scantwentyse () ; 
  30.   else { 
  31.     do { getxtoken () ; 
  32.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  33.     switch ( curcmd ) 
  34.     {case 11 : 
  35.     case 12 : 
  36.       curval = eqtb [ 5573 + curchr ] .cint ; 
  37.       break ; 
  38.     case 15 : 
  39.       scantwentyse () ; 
  40.       break ; 
  41.     default : 
  42.       curval = - 1 ; 
  43.       break ; 
  44.     } 
  45.   } 
  46.   if ( curval < 0 ) 
  47.   {
  48.     {
  49.       if ( interaction == 3 ) 
  50.       wakeuptermin () ; 
  51.       printnl ( 133 ) ; 
  52.       print ( 980 ) ; 
  53.     } 
  54.     {
  55.       helpptr = 6 ; 
  56.       helpline [ 5 ] = 981 ; 
  57.       helpline [ 4 ] = 982 ; 
  58.       helpline [ 3 ] = 983 ; 
  59.       helpline [ 2 ] = 984 ; 
  60.       helpline [ 1 ] = 985 ; 
  61.       helpline [ 0 ] = 986 ; 
  62.     } 
  63.     backerror () ; 
  64.     curval = 0 ; 
  65.   } 
  66.   mem [(long) p ] .qqqq .b0 = ( curval / 1048576 ) % 16 ; 
  67.   mem [(long) p ] .qqqq .b1 = ( curval / 4096 ) % 256 ; 
  68.   mem [(long) p ] .qqqq .b2 = ( curval / 256 ) % 16 ; 
  69.   mem [(long) p ] .qqqq .b3 = curval % 256 ; 
  70. } 
  71. mathradical () { r_mathradical 
  72.   {
  73.     mem [(long) curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  74.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  75.   } 
  76.   mem [(long) curlist .tailfield ] .hh.b0 = 24 ; 
  77.   mem [(long) curlist .tailfield ] .hh.b1 = 0 ; 
  78.   mem [(long) curlist .tailfield + 1 ] .hh = emptyfield ; 
  79.   mem [(long) curlist .tailfield + 3 ] .hh = emptyfield ; 
  80.   mem [(long) curlist .tailfield + 2 ] .hh = emptyfield ; 
  81.   scandelimite ( curlist .tailfield + 4 , true ) ; 
  82.   scanmath ( curlist .tailfield + 1 ) ; 
  83. } 
  84. mathac () { r_mathac 
  85.   if ( curcmd == 45 ) 
  86.   {
  87.     {
  88.       if ( interaction == 3 ) 
  89.       wakeuptermin () ; 
  90.       printnl ( 133 ) ; 
  91.       print ( 987 ) ; 
  92.     } 
  93.     printesc ( 382 ) ; 
  94.     print ( 988 ) ; 
  95.     {
  96.       helpptr = 2 ; 
  97.       helpline [ 1 ] = 989 ; 
  98.       helpline [ 0 ] = 990 ; 
  99.     } 
  100.     error () ; 
  101.   } 
  102.   {
  103.     mem [(long) curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  104.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  105.   } 
  106.   mem [(long) curlist .tailfield ] .hh.b0 = 28 ; 
  107.   mem [(long) curlist .tailfield ] .hh.b1 = 0 ; 
  108.   mem [(long) curlist .tailfield + 1 ] .hh = emptyfield ; 
  109.   mem [(long) curlist .tailfield + 3 ] .hh = emptyfield ; 
  110.   mem [(long) curlist .tailfield + 2 ] .hh = emptyfield ; 
  111.   mem [(long) curlist .tailfield + 4 ] .hh .v.RH = 1 ; 
  112.   scanfifteenb () ; 
  113.   mem [(long) curlist .tailfield + 4 ] .hh.b1 = curval % 256 ; 
  114.   if ( ( curval >= 28672 ) && ( ( eqtb [ 5311 ] .cint >= 0 ) && ( eqtb [ 5311 
  115.   ] .cint < 16 ) ) ) 
  116.   mem [(long) curlist .tailfield + 4 ] .hh.b0 = eqtb [ 5311 ] .cint ; 
  117.   else mem [(long) curlist .tailfield + 4 ] .hh.b0 = ( curval / 256 ) % 16 ; 
  118.   scanmath ( curlist .tailfield + 1 ) ; 
  119. } 
  120. appendchoice () { r_appendchoice 
  121.   {
  122.     mem [(long) curlist .tailfield ] .hh .v.RH = newchoice () ; 
  123.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  124.   } 
  125.   incr ( saveptr ) ; 
  126.   savestack [ saveptr - 1 ] .cint = 0 ; 
  127.   scanleftbrac () ; 
  128.   pushmath ( 13 ) ; 
  129. } 
  130. halfword zfinmlist ( p ) 
  131. halfword p ; 
  132. {register halfword Result; r_finmlist 
  133.   halfword q ; 
  134.   if ( curlist .auxfield != 0 ) 
  135.   {
  136.     mem [(long) curlist .auxfield + 3 ] .hh .v.RH = 3 ; 
  137.     mem [(long) curlist .auxfield + 3 ] .hh .v.LH = mem [(long) curlist .headfield ] .hh 
  138.     .v.RH ; 
  139.     if ( p == 0 ) 
  140.     q = curlist .auxfield ; 
  141.     else { 
  142.       q = mem [(long) curlist .auxfield + 2 ] .hh .v.LH ; 
  143.       if ( mem [(long) q ] .hh.b0 != 30 ) 
  144.       confusion ( 730 ) ; 
  145.       mem [(long) curlist .auxfield + 2 ] .hh .v.LH = mem [(long) q ] .hh .v.RH ; 
  146.       mem [(long) q ] .hh .v.RH = curlist .auxfield ; 
  147.       mem [(long) curlist .auxfield ] .hh .v.RH = p ; 
  148.     } 
  149.   } 
  150.   else { 
  151.     mem [(long) curlist .tailfield ] .hh .v.RH = p ; 
  152.     q = mem [(long) curlist .headfield ] .hh .v.RH ; 
  153.   } 
  154.   popnest () ; 
  155.   Result = q ; 
  156.   return(Result) ; 
  157. } 
  158. buildchoices () { /* 10 */ r_buildchoices 
  159.   halfword p ; 
  160.   unsave () ; 
  161.   p = finmlist ( 0 ) ; 
  162.   switch ( savestack [ saveptr - 1 ] .cint ) 
  163.   {case 0 : 
  164.     mem [(long) curlist .tailfield + 1 ] .hh .v.LH = p ; 
  165.     break ; 
  166.   case 1 : 
  167.     mem [(long) curlist .tailfield + 1 ] .hh .v.RH = p ; 
  168.     break ; 
  169.   case 2 : 
  170.     mem [(long) curlist .tailfield + 2 ] .hh .v.LH = p ; 
  171.     break ; 
  172.   case 3 : 
  173.     {
  174.       mem [(long) curlist .tailfield + 2 ] .hh .v.RH = p ; 
  175.       decr ( saveptr ) ; 
  176.       return ; 
  177.     } 
  178.     break ; 
  179.   } 
  180.   incr ( savestack [ saveptr - 1 ] .cint ) ; 
  181.   scanleftbrac () ; 
  182.   pushmath ( 13 ) ; 
  183. } 
  184. subsup () { r_subsup 
  185.   smallnumber t ; 
  186.   halfword p ; 
  187.   t = 0 ; 
  188.   p = 0 ; 
  189.   if ( curlist .tailfield != curlist .headfield ) 
  190.   if ( ( mem [(long) curlist .tailfield ] .hh.b0 >= 16 ) && ( mem [(long) curlist 
  191.   .tailfield ] .hh.b0 < 30 ) ) 
  192.   {
  193.     p = curlist .tailfield + 2 + curcmd - 7 ; 
  194.     t = mem [(long) p ] .hh .v.RH ; 
  195.   } 
  196.   if ( ( p == 0 ) || ( t != 0 ) ) 
  197.   {
  198.     {
  199.       mem [(long) curlist .tailfield ] .hh .v.RH = newnoad () ; 
  200.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  201.     } 
  202.     p = curlist .tailfield + 2 + curcmd - 7 ; 
  203.     if ( t != 0 ) 
  204.     {
  205.       if ( curcmd == 7 ) 
  206.       {
  207.     {
  208.       if ( interaction == 3 ) 
  209.       wakeuptermin () ; 
  210.       printnl ( 133 ) ; 
  211.       print ( 991 ) ; 
  212.     } 
  213.     {
  214.       helpptr = 1 ; 
  215.       helpline [ 0 ] = 992 ; 
  216.     } 
  217.       } 
  218.       else { 
  219.     {
  220.       if ( interaction == 3 ) 
  221.       wakeuptermin () ; 
  222.       printnl ( 133 ) ; 
  223.       print ( 993 ) ; 
  224.     } 
  225.     {
  226.       helpptr = 1 ; 
  227.       helpline [ 0 ] = 994 ; 
  228.     } 
  229.       } 
  230.       error () ; 
  231.     } 
  232.   } 
  233.   scanmath ( p ) ; 
  234. } 
  235. mathfraction () { r_mathfraction 
  236.   smallnumber c ; 
  237.   c = curchr ; 
  238.   if ( curlist .auxfield != 0 ) 
  239.   {
  240.     if ( c >= 3 ) 
  241.     {
  242.       scandelimite ( memtop - 12 , false ) ; 
  243.       scandelimite ( memtop - 12 , false ) ; 
  244.     } 
  245.     if ( c % 3 == 0 ) 
  246.     scandimen ( false , false , false ) ; 
  247.     {
  248.       if ( interaction == 3 ) 
  249.       wakeuptermin () ; 
  250.       printnl ( 133 ) ; 
  251.       print ( 1001 ) ; 
  252.     } 
  253.     {
  254.       helpptr = 3 ; 
  255.       helpline [ 2 ] = 1002 ; 
  256.       helpline [ 1 ] = 1003 ; 
  257.       helpline [ 0 ] = 1004 ; 
  258.     } 
  259.     error () ; 
  260.   } 
  261.   else { 
  262.     curlist .auxfield = getnode ( 6 ) ; 
  263.     mem [(long) curlist .auxfield ] .hh.b0 = 25 ; 
  264.     mem [(long) curlist .auxfield ] .hh.b1 = 0 ; 
  265.     mem [(long) curlist .auxfield + 2 ] .hh .v.RH = 3 ; 
  266.     mem [(long) curlist .auxfield + 2 ] .hh .v.LH = mem [(long) curlist .headfield ] .hh 
  267.     .v.RH ; 
  268.     mem [(long) curlist .auxfield + 3 ] .hh = emptyfield ; 
  269.     mem [(long) curlist .auxfield + 4 ] .qqqq = nulldelimite ; 
  270.     mem [(long) curlist .auxfield + 5 ] .qqqq = nulldelimite ; 
  271.     mem [(long) curlist .headfield ] .hh .v.RH = 0 ; 
  272.     curlist .tailfield = curlist .headfield ; 
  273.     if ( c >= 3 ) 
  274.     {
  275.       scandelimite ( curlist .auxfield + 4 , false ) ; 
  276.       scandelimite ( curlist .auxfield + 5 , false ) ; 
  277.     } 
  278.     switch ( c % 3 ) 
  279.     {case 0 : 
  280.       {
  281.     scandimen ( false , false , false ) ; 
  282.     mem [(long) curlist .auxfield + 1 ] .cint = curval ; 
  283.       } 
  284.       break ; 
  285.     case 1 : 
  286.       mem [(long) curlist .auxfield + 1 ] .cint = 1073741824 ; 
  287.       break ; 
  288.     case 2 : 
  289.       mem [(long) curlist .auxfield + 1 ] .cint = 0 ; 
  290.       break ; 
  291.     } 
  292.   } 
  293. } 
  294. mathleftrigh () { r_mathleftrigh 
  295.   smallnumber t ; 
  296.   halfword p ; 
  297.   t = curchr ; 
  298.   if ( ( t == 31 ) && ( curgroup != 16 ) ) 
  299.   {
  300.     if ( curgroup == 15 ) 
  301.     {
  302.       scandelimite ( memtop - 12 , false ) ; 
  303.       {
  304.     if ( interaction == 3 ) 
  305.     wakeuptermin () ; 
  306.     printnl ( 133 ) ; 
  307.     print ( 633 ) ; 
  308.       } 
  309.       printesc ( 730 ) ; 
  310.       {
  311.     helpptr = 1 ; 
  312.     helpline [ 0 ] = 1005 ; 
  313.       } 
  314.       error () ; 
  315.     } 
  316.     else offsave () ; 
  317.   } 
  318.   else { 
  319.     p = newnoad () ; 
  320.     mem [(long) p ] .hh.b0 = t ; 
  321.     scandelimite ( p + 1 , false ) ; 
  322.     if ( t == 30 ) 
  323.     {
  324.       pushmath ( 16 ) ; 
  325.       mem [(long) curlist .headfield ] .hh .v.RH = p ; 
  326.       curlist .tailfield = p ; 
  327.     } 
  328.     else { 
  329.       p = finmlist ( p ) ; 
  330.       unsave () ; 
  331.       {
  332.     mem [(long) curlist .tailfield ] .hh .v.RH = newnoad () ; 
  333.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  334.       } 
  335.       mem [(long) curlist .tailfield ] .hh.b0 = 23 ; 
  336.       mem [(long) curlist .tailfield + 1 ] .hh .v.RH = 3 ; 
  337.       mem [(long) curlist .tailfield + 1 ] .hh .v.LH = p ; 
  338.     } 
  339.   } 
  340. } 
  341. aftermath () { r_aftermath 
  342.   boolean l ; 
  343.   boolean danger ; 
  344.   integer m ; 
  345.   halfword p ; 
  346.   halfword a ; 
  347.   halfword b ; 
  348.   scaled w ; 
  349.   scaled z ; 
  350.   scaled e ; 
  351.   scaled q ; 
  352.   scaled d ; 
  353.   scaled s ; 
  354.   smallnumber g1, g2 ; 
  355.   halfword r ; 
  356.   halfword t ; 
  357.   danger = false ; 
  358.   if ( ( fontparams [ eqtb [ 4581 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb 
  359.   [ 4597 ] .hh .v.RH ] < 22 ) || ( fontparams [ eqtb [ 4613 ] .hh .v.RH ] < 22 
  360.   ) ) 
  361.   {
  362.     {
  363.       if ( interaction == 3 ) 
  364.       wakeuptermin () ; 
  365.       printnl ( 133 ) ; 
  366.       print ( 1006 ) ; 
  367.     } 
  368.     {
  369.       helpptr = 3 ; 
  370.       helpline [ 2 ] = 1007 ; 
  371.       helpline [ 1 ] = 1008 ; 
  372.       helpline [ 0 ] = 1009 ; 
  373.     } 
  374.     error () ; 
  375.     flushmath () ; 
  376.     danger = true ; 
  377.   } 
  378.   else if ( ( fontparams [ eqtb [ 4582 ] .hh .v.RH ] < 13 ) || ( fontparams [ 
  379.   eqtb [ 4598 ] .hh .v.RH ] < 13 ) || ( fontparams [ eqtb [ 4614 ] .hh .v.RH ] 
  380.   < 13 ) ) 
  381.   {
  382.     {
  383.       if ( interaction == 3 ) 
  384.       wakeuptermin () ; 
  385.       printnl ( 133 ) ; 
  386.       print ( 1010 ) ; 
  387.     } 
  388.     {
  389.       helpptr = 3 ; 
  390.       helpline [ 2 ] = 1011 ; 
  391.       helpline [ 1 ] = 1012 ; 
  392.       helpline [ 0 ] = 1013 ; 
  393.     } 
  394.     error () ; 
  395.     flushmath () ; 
  396.     danger = true ; 
  397.   } 
  398.   m = curlist .modefield ; 
  399.   l = false ; 
  400.   p = finmlist ( 0 ) ; 
  401.   if ( curlist .modefield == - m ) 
  402.   {
  403.     curmlist = p ; 
  404.     curstyle = 2 ; 
  405.     mlistpenalti = false ; 
  406.     mlisttohlist () ; 
  407.     a = hpack ( mem [(long) memtop - 3 ] .hh .v.RH , 0 , 1 ) ; 
  408.     unsave () ; 
  409.     decr ( saveptr ) ; 
  410.     if ( savestack [ saveptr + 0 ] .cint == 1 ) 
  411.     l = true ; 
  412.     if ( danger ) 
  413.     flushmath () ; 
  414.     m = curlist .modefield ; 
  415.     p = finmlist ( 0 ) ; 
  416.   } 
  417.   else a = 0 ; 
  418.   if ( m < 0 ) 
  419.   {
  420.     {
  421.       mem [(long) curlist .tailfield ] .hh .v.RH = newmath ( eqtb [ 5702 ] .cint , 0 
  422.       ) ; 
  423.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  424.     } 
  425.     curmlist = p ; 
  426.     curstyle = 2 ; 
  427.     mlistpenalti = ( curlist .modefield > 0 ) ; 
  428.     mlisttohlist () ; 
  429.     mem [(long) curlist .tailfield ] .hh .v.RH = mem [(long) memtop - 3 ] .hh .v.RH ; 
  430.     while ( mem [(long) curlist .tailfield ] .hh .v.RH != 0 ) curlist .tailfield = 
  431.     mem [(long) curlist .tailfield ] .hh .v.RH ; 
  432.     {
  433.       mem [(long) curlist .tailfield ] .hh .v.RH = newmath ( eqtb [ 5702 ] .cint , 1 
  434.       ) ; 
  435.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  436.     } 
  437.     curlist .auxfield = 1000 ; 
  438.     unsave () ; 
  439.   } 
  440.   else { 
  441.     {
  442.       getxtoken () ; 
  443.       if ( curcmd != 3 ) 
  444.       {
  445.     {
  446.       if ( interaction == 3 ) 
  447.       wakeuptermin () ; 
  448.       printnl ( 133 ) ; 
  449.       print ( 1014 ) ; 
  450.     } 
  451.     {
  452.       helpptr = 2 ; 
  453.       helpline [ 1 ] = 1015 ; 
  454.       helpline [ 0 ] = 1016 ; 
  455.     } 
  456.     backerror () ; 
  457.       } 
  458.     } 
  459.     curmlist = p ; 
  460.     curstyle = 0 ; 
  461.     mlistpenalti = false ; 
  462.     mlisttohlist () ; 
  463.     p = mem [(long) memtop - 3 ] .hh .v.RH ; 
  464.     adjusttail = memtop - 5 ; 
  465.     b = hpack ( p , 0 , 1 ) ; 
  466.     t = adjusttail ; 
  467.     adjusttail = 0 ; 
  468.     w = mem [(long) b + 1 ] .cint ; 
  469.     z = eqtb [ 5715 ] .cint ; 
  470.     s = eqtb [ 5716 ] .cint ; 
  471.     if ( ( a == 0 ) || danger ) 
  472.     {
  473.       e = 0 ; 
  474.       q = 0 ; 
  475.     } 
  476.     else { 
  477.       e = mem [(long) a + 1 ] .cint ; 
  478.       q = e + fontinfo [ 6 + parambase [ eqtb [ 4581 ] .hh .v.RH ] ] .cint ; 
  479.     } 
  480.     if ( w + q > z ) 
  481.     {
  482.       if ( ( e != 0 ) && ( ( w - totalshrink [ 0 ] + q <= z ) || ( totalshrink 
  483.       [ 1 ] != 0 ) || ( totalshrink [ 2 ] != 0 ) || ( totalshrink [ 3 ] != 0 ) 
  484.       ) ) 
  485.       {
  486.     freenode ( b , 7 ) ; 
  487.     b = hpack ( p , z - q , 0 ) ; 
  488.       } 
  489.       else { 
  490.     e = 0 ; 
  491.     if ( w > z ) 
  492.     {
  493.       freenode ( b , 7 ) ; 
  494.       b = hpack ( p , z , 0 ) ; 
  495.     } 
  496.       } 
  497.       w = mem [(long) b + 1 ] .cint ; 
  498.     } 
  499.     d = half ( z - w ) ; 
  500.     if ( ( e > 0 ) && ( d < 2 * e ) ) 
  501.     {
  502.       d = half ( z - w - e ) ; 
  503.       if ( p != 0 ) 
  504.       if ( mem [(long) p ] .hh.b0 == 10 ) 
  505.       d = 0 ; 
  506.     } 
  507.     {
  508.       mem [(long) curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5278 ] .cint 
  509.       ) ; 
  510.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  511.     } 
  512.     if ( ( d + s <= eqtb [ 5714 ] .cint ) || l ) 
  513.     {
  514.       g1 = 3 ; 
  515.       g2 = 4 ; 
  516.     } 
  517.     else { 
  518.       g1 = 5 ; 
  519.       g2 = 6 ; 
  520.     } 
  521.     if ( l && ( e == 0 ) ) 
  522.     {
  523.       mem [(long) a + 4 ] .cint = s ; 
  524.       appendtovlis ( a ) ; 
  525.       {
  526.     mem [(long) curlist .tailfield ] .hh .v.RH = newpenalty ( 10000 ) ; 
  527.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  528.       } 
  529.     } 
  530.     else { 
  531.       mem [(long) curlist .tailfield ] .hh .v.RH = newparamglue ( g1 ) ; 
  532.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  533.     } 
  534.     if ( e != 0 ) 
  535.     {
  536.       r = newkern ( z - w - e - d ) ; 
  537.       if ( l ) 
  538.       {
  539.     mem [(long) a ] .hh .v.RH = r ; 
  540.     mem [(long) r ] .hh .v.RH = b ; 
  541.     b = a ; 
  542.     d = 0 ; 
  543.       } 
  544.       else { 
  545.     mem [(long) b ] .hh .v.RH = r ; 
  546.     mem [(long) r ] .hh .v.RH = a ; 
  547.       } 
  548.       b = hpack ( b , 0 , 1 ) ; 
  549.     } 
  550.     mem [(long) b + 4 ] .cint = s + d ; 
  551.     appendtovlis ( b ) ; 
  552.     if ( t != memtop - 5 ) 
  553.     {
  554.       mem [(long) curlist .tailfield ] .hh .v.RH = mem [(long) memtop - 5 ] .hh .v.RH ; 
  555.       curlist .tailfield = t ; 
  556.     } 
  557.     if ( ( a != 0 ) && ( e == 0 ) && ! l ) 
  558.     {
  559.       {
  560.     mem [(long) curlist .tailfield ] .hh .v.RH = newpenalty ( 10000 ) ; 
  561.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  562.       } 
  563.       mem [(long) a + 4 ] .cint = s + z - mem [(long) a + 1 ] .cint ; 
  564.       appendtovlis ( a ) ; 
  565.       {
  566.     mem [(long) curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5279 ] 
  567.     .cint ) ; 
  568.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  569.       } 
  570.     } 
  571.     else { 
  572.       {
  573.     mem [(long) curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5279 ] 
  574.     .cint ) ; 
  575.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  576.       } 
  577.       {
  578.     mem [(long) curlist .tailfield ] .hh .v.RH = newparamglue ( g2 ) ; 
  579.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  580.       } 
  581.     } 
  582.     resumeafterd () ; 
  583.   } 
  584. } 
  585. resumeafterd () { r_resumeafterd 
  586.   if ( curgroup != 15 ) 
  587.   confusion ( 1017 ) ; 
  588.   unsave () ; 
  589.   curlist .pgfield = curlist .pgfield + 3 ; 
  590.   pushnest () ; 
  591.   curlist .modefield = 101 ; 
  592.   curlist .auxfield = 1000 ; 
  593.   {
  594.     getxtoken () ; 
  595.     if ( curcmd != 10 ) 
  596.     backinput () ; 
  597.   } 
  598.   if ( nestptr == 1 ) 
  599.   buildpage () ; 
  600. } 
  601. getrtoken () { /* 20 */ r_getrtoken 
  602.   lab20: do { gettoken () ; 
  603.   } while ( ! ( curtok != 2592 ) ) ; 
  604.   if ( ( curcs == 0 ) || ( curcs > 3258 ) ) 
  605.   {
  606.     {
  607.       if ( interaction == 3 ) 
  608.       wakeuptermin () ; 
  609.       printnl ( 133 ) ; 
  610.       print ( 1032 ) ; 
  611.     } 
  612.     {
  613.       helpptr = 5 ; 
  614.       helpline [ 4 ] = 1033 ; 
  615.       helpline [ 3 ] = 1034 ; 
  616.       helpline [ 2 ] = 1035 ; 
  617.       helpline [ 1 ] = 1036 ; 
  618.       helpline [ 0 ] = 1037 ; 
  619.     } 
  620.     if ( curcs == 0 ) 
  621.     backinput () ; 
  622.     curtok = 7354 ; 
  623.     inserror () ; 
  624.     goto lab20 ; 
  625.   } 
  626. } 
  627. trapzeroglue () { r_trapzeroglue 
  628.   if ( ( mem [(long) curval + 1 ] .cint == 0 ) && ( mem [(long) curval + 2 ] .cint == 0 ) 
  629.   && ( mem [(long) curval + 3 ] .cint == 0 ) ) 
  630.   {
  631.     incr ( mem [(long) 0 ] .hh .v.RH ) ; 
  632.     deletegluere ( curval ) ; 
  633.     curval = 0 ; 
  634.   } 
  635. } 
  636. zdoregisterco ( a ) 
  637. smallnumber a ; 
  638. {/* 40 10 */ r_doregisterco 
  639.   halfword l, q, r, s ; 
  640.   quarterword p ; 
  641.   q = curcmd ; 
  642.   {
  643.     if ( q != 88 ) 
  644.     {
  645.       getxtoken () ; 
  646.       if ( ( curcmd >= 72 ) && ( curcmd <= 75 ) ) 
  647.       {
  648.     l = curchr ; 
  649.     p = curcmd - 72 ; 
  650.     goto lab40 ; 
  651.       } 
  652.       if ( curcmd != 88 ) 
  653.       {
  654.     {
  655.       if ( interaction == 3 ) 
  656.       wakeuptermin () ; 
  657.       printnl ( 133 ) ; 
  658.       print ( 541 ) ; 
  659.     } 
  660.     printcmdchr ( curcmd , curchr ) ; 
  661.     print ( 542 ) ; 
  662.     printcmdchr ( q , 0 ) ; 
  663.     {
  664.       helpptr = 1 ; 
  665.       helpline [ 0 ] = 1058 ; 
  666.     } 
  667.     error () ; 
  668.     return ; 
  669.       } 
  670.     } 
  671.     p = curchr ; 
  672.     scaneightbit () ; 
  673.     switch ( p ) 
  674.     {case 0 : 
  675.       l = curval + 5317 ; 
  676.       break ; 
  677.     case 1 : 
  678.       l = curval + 5721 ; 
  679.       break ; 
  680.     case 2 : 
  681.       l = curval + 3544 ; 
  682.       break ; 
  683.     case 3 : 
  684.       l = curval + 3800 ; 
  685.       break ; 
  686.     } 
  687.   } 
  688.   lab40: ; 
  689.   if ( q == 88 ) 
  690.   scanoptional () ; 
  691.   else if ( scankeyword ( 1054 ) ) 
  692.   ; 
  693.   aritherror = false ; 
  694.   if ( q < 90 ) 
  695.   if ( p < 2 ) 
  696.   {
  697.     if ( p == 0 ) 
  698.     scanint () ; 
  699.     else scandimen ( false , false , false ) ; 
  700.     if ( q == 89 ) 
  701.     curval = curval + eqtb [ l ] .cint ; 
  702.   } 
  703.   else { 
  704.     scanglue ( p ) ; 
  705.     if ( q == 89 ) 
  706.     {
  707.       q = newspec ( curval ) ; 
  708.       r = eqtb [ l ] .hh .v.RH ; 
  709.       deletegluere ( curval ) ; 
  710.       mem [(long) q + 1 ] .cint = mem [(long) q + 1 ] .cint + mem [(long) r + 1 ] .cint ; 
  711.       if ( mem [(long) q + 2 ] .cint == 0 ) 
  712.       mem [(long) q ] .hh.b0 = 0 ; 
  713.       if ( mem [(long) q ] .hh.b0 == mem [(long) r ] .hh.b0 ) 
  714.       mem [(long) q + 2 ] .cint = mem [(long) q + 2 ] .cint + mem [(long) r + 2 ] .cint ; 
  715.       else if ( ( mem [(long) q ] .hh.b0 < mem [(long) r ] .hh.b0 ) && ( mem [(long) r + 2 ] 
  716.       .cint != 0 ) ) 
  717.       {
  718.     mem [(long) q + 2 ] .cint = mem [(long) r + 2 ] .cint ; 
  719.     mem [(long) q ] .hh.b0 = mem [(long) r ] .hh.b0 ; 
  720.       } 
  721.       if ( mem [(long) q + 3 ] .cint == 0 ) 
  722.       mem [(long) q ] .hh.b1 = 0 ; 
  723.       if ( mem [(long) q ] .hh.b1 == mem [(long) r ] .hh.b1 ) 
  724.       mem [(long) q + 3 ] .cint = mem [(long) q + 3 ] .cint + mem [(long) r + 3 ] .cint ; 
  725.       else if ( ( mem [(long) q ] .hh.b1 < mem [(long) r ] .hh.b1 ) && ( mem [(long) r + 3 ] 
  726.       .cint != 0 ) ) 
  727.       {
  728.     mem [(long) q + 3 ] .cint = mem [(long) r + 3 ] .cint ; 
  729.     mem [(long) q ] .hh.b1 = mem [(long) r ] .hh.b1 ; 
  730.       } 
  731.       curval = q ; 
  732.     } 
  733.   } 
  734.   else { 
  735.     scanint () ; 
  736.     if ( p < 2 ) 
  737.     if ( q == 90 ) 
  738.     curval = nxplusy ( eqtb [ l ] .cint , curval , 0 ) ; 
  739.     else curval = xovern ( eqtb [ l ] .cint , curval ) ; 
  740.     else { 
  741.       s = eqtb [ l ] .hh .v.RH ; 
  742.       r = newspec ( s ) ; 
  743.       if ( q == 90 ) 
  744.       {
  745.     mem [(long) r + 1 ] .cint = nxplusy ( mem [(long) s + 1 ] .cint , curval , 0 ) ; 
  746.     mem [(long) r + 2 ] .cint = nxplusy ( mem [(long) s + 2 ] .cint , curval , 0 ) ; 
  747.     mem [(long) r + 3 ] .cint = nxplusy ( mem [(long) s + 3 ] .cint , curval , 0 ) ; 
  748.       } 
  749.       else { 
  750.     mem [(long) r + 1 ] .cint = xovern ( mem [(long) s + 1 ] .cint , curval ) ; 
  751.     mem [(long) r + 2 ] .cint = xovern ( mem [(long) s + 2 ] .cint , curval ) ; 
  752.     mem [(long) r + 3 ] .cint = xovern ( mem [(long) s + 3 ] .cint , curval ) ; 
  753.       } 
  754.       curval = r ; 
  755.     } 
  756.   } 
  757.   if ( aritherror ) 
  758.   {
  759.     {
  760.       if ( interaction == 3 ) 
  761.       wakeuptermin () ; 
  762.       printnl ( 133 ) ; 
  763.       print ( 1055 ) ; 
  764.     } 
  765.     {
  766.       helpptr = 2 ; 
  767.       helpline [ 1 ] = 1056 ; 
  768.       helpline [ 0 ] = 1057 ; 
  769.     } 
  770.     error () ; 
  771.     return ; 
  772.   } 
  773.   if ( p < 2 ) 
  774.   if ( ( a >= 4 ) ) 
  775.   geqworddefin ( l , curval ) ; 
  776.   else eqworddefine ( l , curval ) ; 
  777.   else { 
  778.     trapzeroglue () ; 
  779.     if ( ( a >= 4 ) ) 
  780.     geqdefine ( l , 116 , curval ) ; 
  781.     else eqdefine ( l , 116 , curval ) ; 
  782.   } 
  783. } 
  784. alteraux () { r_alteraux 
  785.   halfword c ; 
  786.   if ( curchr != abs ( curlist .modefield ) ) 
  787.   reportillega () ; 
  788.   else { 
  789.     c = curchr ; 
  790.     scanoptional () ; 
  791.     if ( c == 1 ) 
  792.     {
  793.       scandimen ( false , false , false ) ; 
  794.       curlist .auxfield = curval ; 
  795.     } 
  796.     else { 
  797.       scanint () ; 
  798.       if ( ( curval <= 0 ) || ( curval > 32767 ) ) 
  799.       {
  800.     {
  801.       if ( interaction == 3 ) 
  802.       wakeuptermin () ; 
  803.       printnl ( 133 ) ; 
  804.       print ( 1059 ) ; 
  805.     } 
  806.     {
  807.       helpptr = 1 ; 
  808.       helpline [ 0 ] = 1060 ; 
  809.     } 
  810.     interror ( curval ) ; 
  811.       } 
  812.       else curlist .auxfield = curval ; 
  813.     } 
  814.   } 
  815. } 
  816. alterprevgra () { r_alterprevgra 
  817.   integer p ; 
  818.   nest [ nestptr ] = curlist ; 
  819.   p = nestptr ; 
  820.   while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  821.   scanoptional () ; 
  822.   scanint () ; 
  823.   if ( curval < 0 ) 
  824.   {
  825.     {
  826.       if ( interaction == 3 ) 
  827.       wakeuptermin () ; 
  828.       printnl ( 133 ) ; 
  829.       print ( 802 ) ; 
  830.     } 
  831.     printesc ( 390 ) ; 
  832.     {
  833.       helpptr = 1 ; 
  834.       helpline [ 0 ] = 1061 ; 
  835.     } 
  836.     interror ( curval ) ; 
  837.   } 
  838.   else { 
  839.     nest [ p ] .pgfield = curval ; 
  840.     curlist = nest [ nestptr ] ; 
  841.   } 
  842. } 
  843. alterpagesof () { r_alterpagesof 
  844.   quarterword c ; 
  845.   c = curchr ; 
  846.   scanoptional () ; 
  847.   scandimen ( false , false , false ) ; 
  848.   pagesofar [ c ] = curval ; 
  849. } 
  850. alterinteger () { r_alterinteger 
  851.   quarterword c ; 
  852.   c = curchr ; 
  853.   scanoptional () ; 
  854.   scanint () ; 
  855.   if ( c == 0 ) 
  856.   deadcycles = curval ; 
  857.   else insertpenalt = curval ; 
  858. } 
  859. alterboxdime () { r_alterboxdime 
  860.   smallnumber c ; 
  861.   eightbits b ; 
  862.   c = curchr ; 
  863.   scaneightbit () ; 
  864.   b = curval ; 
  865.   scanoptional () ; 
  866.   scandimen ( false , false , false ) ; 
  867.   if ( eqtb [ 4322 + b ] .hh .v.RH != 0 ) 
  868.   mem [(long) eqtb [ 4322 + b ] .hh .v.RH + c ] .cint = curval ; 
  869. } 
  870. znewfont ( a ) 
  871. smallnumber a ; 
  872. {/* 50 */ r_newfont 
  873.   halfword u ; 
  874.   scaled s ; 
  875.   internalfont f ; 
  876.   strnumber t ; 
  877.   quarterword oldsetting ; 
  878.   if ( jobname == 0 ) 
  879.   openlogfile () ; 
  880.   getrtoken () ; 
  881.   u = curcs ; 
  882.   if ( u >= 258 ) 
  883.   t = hash [ u ] .v.RH ; 
  884.   else if ( u >= 129 ) 
  885.   if ( u == 257 ) 
  886.   t = 1065 ; 
  887.   else t = u - 129 ; 
  888.   else { 
  889.     oldsetting = selector ; 
  890.     selector = 21 ; 
  891.     print ( 1065 ) ; 
  892.     print ( u - 1 ) ; 
  893.     selector = oldsetting ; 
  894.     {
  895.       if ( poolptr + 1 > poolsize ) 
  896.       overflow ( 128 , poolsize - initpoolptr ) ; 
  897.     } 
  898.     t = makestring () ; 
  899.   } 
  900.   if ( ( a >= 4 ) ) 
  901.   geqdefine ( u , 86 , 0 ) ; 
  902.   else eqdefine ( u , 86 , 0 ) ; 
  903.   scanoptional () ; 
  904.   scanfilename () ; 
  905.   nameinprogre = true ; 
  906.   if ( scankeyword ( 1066 ) ) 
  907.   {
  908.     scandimen ( false , false , false ) ; 
  909.     s = curval ; 
  910.     if ( ( s <= 0 ) || ( s >= 134217728 ) ) 
  911.     {
  912.       {
  913.     if ( interaction == 3 ) 
  914.     wakeuptermin () ; 
  915.     printnl ( 133 ) ; 
  916.     print ( 1068 ) ; 
  917.       } 
  918.       printscaled ( s ) ; 
  919.       print ( 1069 ) ; 
  920.       {
  921.     helpptr = 2 ; 
  922.     helpline [ 1 ] = 1070 ; 
  923.     helpline [ 0 ] = 1071 ; 
  924.       } 
  925.       error () ; 
  926.       s = 10 * 65536 ; 
  927.     } 
  928.   } 
  929.   else if ( scankeyword ( 1067 ) ) 
  930.   {
  931.     scanint () ; 
  932.     s = - curval ; 
  933.     if ( ( curval <= 0 ) || ( curval > 32768 ) ) 
  934.     {
  935.       {
  936.     if ( interaction == 3 ) 
  937.     wakeuptermin () ; 
  938.     printnl ( 133 ) ; 
  939.     print ( 410 ) ; 
  940.       } 
  941.       {
  942.     helpptr = 1 ; 
  943.     helpline [ 0 ] = 411 ; 
  944.       } 
  945.       interror ( curval ) ; 
  946.       s = - 1000 ; 
  947.     } 
  948.   } 
  949.   else s = - 1000 ; 
  950.   nameinprogre = false ; 
  951.   for ( f = 1 ; f <= fontptr ; f ++ ) 
  952.   if ( streqstr ( fontname [ f ] , curname ) && streqstr ( fontarea [ f ] , 
  953.   curarea ) ) 
  954.   {
  955.     if ( s > 0 ) 
  956.     {
  957.       if ( s == fontsize [ f ] ) 
  958.       goto lab50 ; 
  959.     } 
  960.     else if ( fontsize [ f ] == xnoverd ( fontdsize [ f ] , - s , 1000 ) ) 
  961.     goto lab50 ; 
  962.   } 
  963.   f = readfontinfo ( u , curname , curarea , s ) ; 
  964.   lab50: eqtb [ u ] .hh .v.RH = f ; 
  965.   eqtb [ 3268 + f ] = eqtb [ u ] ; 
  966.   hash [ 3268 + f ] .v.RH = t ; 
  967. } 
  968. newinteracti () { r_newinteracti 
  969.   println () ; 
  970.   interaction = curchr ; 
  971.   if ( interaction == 0 ) 
  972.   selector = 16 ; 
  973.   else selector = 17 ; 
  974.   if ( jobname != 0 ) 
  975.   selector = selector + 2 ; 
  976. } 
  977. prefixedcomm () { /* 30 10 */ r_prefixedcomm 
  978.   smallnumber a ; 
  979.   internalfont f ; 
  980.   halfword j ; 
  981.   integer k ; 
  982.   halfword p, q ; 
  983.   integer n ; 
  984.   boolean e ; 
  985.   a = 0 ; 
  986.   while ( curcmd == 92 ) { 
  987.     if ( ! odd ( a / curchr ) ) 
  988.     a = a + curchr ; 
  989.     do { getxtoken () ; 
  990.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  991.     if ( curcmd <= 69 ) 
  992.     {
  993.       {
  994.     if ( interaction == 3 ) 
  995.     wakeuptermin () ; 
  996.     printnl ( 133 ) ; 
  997.     print ( 1027 ) ; 
  998.       } 
  999.       printcmdchr ( curcmd , curchr ) ; 
  1000.       printchar ( 39 ) ; 
  1001.       {
  1002.     helpptr = 1 ; 
  1003.     helpline [ 0 ] = 1028 ; 
  1004.       } 
  1005.       backerror () ; 
  1006.       return ; 
  1007.     } 
  1008.   } 
  1009.   if ( ( curcmd != 96 ) && ( a % 4 != 0 ) ) 
  1010.   {
  1011.     {
  1012.       if ( interaction == 3 ) 
  1013.       wakeuptermin () ; 
  1014.       printnl ( 133 ) ; 
  1015.       print ( 541 ) ; 
  1016.     } 
  1017.     printesc ( 1019 ) ; 
  1018.     print ( 1029 ) ; 
  1019.     printesc ( 1020 ) ; 
  1020.     print ( 1030 ) ; 
  1021.     printcmdchr ( curcmd , curchr ) ; 
  1022.     printchar ( 39 ) ; 
  1023.     {
  1024.       helpptr = 1 ; 
  1025.       helpline [ 0 ] = 1031 ; 
  1026.     } 
  1027.     error () ; 
  1028.   } 
  1029.   if ( eqtb [ 5310 ] .cint != 0 ) 
  1030.   if ( eqtb [ 5310 ] .cint < 0 ) 
  1031.   {
  1032.     if ( ( a >= 4 ) ) 
  1033.     a = a - 4 ; 
  1034.   } 
  1035.   else { 
  1036.     if ( ! ( a >= 4 ) ) 
  1037.     a = a + 4 ; 
  1038.   } 
  1039.   switch ( curcmd ) 
  1040.   {case 86 : 
  1041.     if ( ( a >= 4 ) ) 
  1042.     geqdefine ( 4578 , 119 , curchr ) ; 
  1043.     else eqdefine ( 4578 , 119 , curchr ) ; 
  1044.     break ; 
  1045.   case 96 : 
  1046.     {
  1047.       if ( odd ( curchr ) && ! ( a >= 4 ) && ( eqtb [ 5310 ] .cint >= 0 ) ) 
  1048.       a = a + 4 ; 
  1049.       e = ( curchr >= 2 ) ; 
  1050.       getrtoken () ; 
  1051.       p = curcs ; 
  1052.       q = scantoks ( true , e ) ; 
  1053.       if ( ( a >= 4 ) ) 
  1054.       geqdefine ( p , 110 + ( a % 4 ) , defref ) ; 
  1055.       else eqdefine ( p , 110 + ( a % 4 ) , defref ) ; 
  1056.     } 
  1057.     break ; 
  1058.   case 93 : 
  1059.     {
  1060.       n = curchr ; 
  1061.       getrtoken () ; 
  1062.       p = curcs ; 
  1063.       if ( n == 0 ) 
  1064.       {
  1065.     do { gettoken () ; 
  1066.     } while ( ! ( curcmd != 10 ) ) ; 
  1067.     if ( curtok == 3133 ) 
  1068.     {
  1069.       gettoken () ; 
  1070.       if ( curcmd == 10 ) 
  1071.       gettoken () ; 
  1072.     } 
  1073.       } 
  1074.       else { 
  1075.     gettoken () ; 
  1076.     q = curtok ; 
  1077.     gettoken () ; 
  1078.     backinput () ; 
  1079.     curtok = q ; 
  1080.     backinput () ; 
  1081.       } 
  1082.       if ( curcmd >= 110 ) 
  1083.       incr ( mem [(long) curchr ] .hh .v.LH ) ; 
  1084.       if ( ( a >= 4 ) ) 
  1085.       geqdefine ( p , curcmd , curchr ) ; 
  1086.       else eqdefine ( p , curcmd , curchr ) ; 
  1087.     } 
  1088.     break ; 
  1089.   case 94 : 
  1090.     {
  1091.       n = curchr ; 
  1092.       getrtoken () ; 
  1093.       p = curcs ; 
  1094.       if ( ( a >= 4 ) ) 
  1095.       geqdefine ( p , 0 , 256 ) ; 
  1096.       else eqdefine ( p , 0 , 256 ) ; 
  1097.       scanoptional () ; 
  1098.       switch ( n ) 
  1099.       {case 0 : 
  1100.     {
  1101.       scancharnum () ; 
  1102.       if ( ( a >= 4 ) ) 
  1103.       geqdefine ( p , 67 , curval ) ; 
  1104.       else eqdefine ( p , 67 , curval ) ; 
  1105.     } 
  1106.     break ; 
  1107.       case 1 : 
  1108.     {
  1109.       scanfifteenb () ; 
  1110.       if ( ( a >= 4 ) ) 
  1111.       geqdefine ( p , 68 , curval ) ; 
  1112.       else eqdefine ( p , 68 , curval ) ; 
  1113.     } 
  1114.     break ; 
  1115.       default : 
  1116.     {
  1117.       scaneightbit () ; 
  1118.       switch ( n ) 
  1119.       {case 2 : 
  1120.         if ( ( a >= 4 ) ) 
  1121.         geqdefine ( p , 72 , 5317 + curval ) ; 
  1122.         else eqdefine ( p , 72 , 5317 + curval ) ; 
  1123.         break ; 
  1124.       case 3 : 
  1125.         if ( ( a >= 4 ) ) 
  1126.         geqdefine ( p , 73 , 5721 + curval ) ; 
  1127.         else eqdefine ( p , 73 , 5721 + curval ) ; 
  1128.         break ; 
  1129.       case 4 : 
  1130.         if ( ( a >= 4 ) ) 
  1131.         geqdefine ( p , 74 , 3544 + curval ) ; 
  1132.         else eqdefine ( p , 74 , 3544 + curval ) ; 
  1133.         break ; 
  1134.       case 5 : 
  1135.         if ( ( a >= 4 ) ) 
  1136.         geqdefine ( p , 75 , 3800 + curval ) ; 
  1137.         else eqdefine ( p , 75 , 3800 + curval ) ; 
  1138.         break ; 
  1139.       case 6 : 
  1140.         if ( ( a >= 4 ) ) 
  1141.         geqdefine ( p , 71 , 4066 + curval ) ; 
  1142.         else eqdefine ( p , 71 , 4066 + curval ) ; 
  1143.         break ; 
  1144.       } 
  1145.     } 
  1146.     break ; 
  1147.       } 
  1148.     } 
  1149.     break ; 
  1150.   case 95 : 
  1151.     {
  1152.       scanint () ; 
  1153.       n = curval ; 
  1154.       if ( ! scankeyword ( 695 ) ) 
  1155.       {
  1156.     {
  1157.       if ( interaction == 3 ) 
  1158.       wakeuptermin () ; 
  1159.       printnl ( 133 ) ; 
  1160.       print ( 921 ) ; 
  1161.     } 
  1162.     {
  1163.       helpptr = 2 ; 
  1164.       helpline [ 1 ] = 1048 ; 
  1165.       helpline [ 0 ] = 1049 ; 
  1166.     } 
  1167.     error () ; 
  1168.       } 
  1169.       getrtoken () ; 
  1170.       p = curcs ; 
  1171.       readtoks ( n , p ) ; 
  1172.       if ( ( a >= 4 ) ) 
  1173.       geqdefine ( p , 110 , curval ) ; 
  1174.       else eqdefine ( p , 110 , curval ) ; 
  1175.     } 
  1176.     break ; 
  1177.   case 70 : 
  1178.   case 71 : 
  1179.     {
  1180.       q = curcs ; 
  1181.       if ( curcmd == 70 ) 
  1182.       {
  1183.     scaneightbit () ; 
  1184.     p = 4066 + curval ; 
  1185.       } 
  1186.       else p = curchr ; 
  1187.       scanoptional () ; 
  1188.       do { getxtoken () ; 
  1189.       } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1190.       if ( curcmd != 1 ) 
  1191.       {
  1192.     if ( curcmd == 70 ) 
  1193.     {
  1194.       scaneightbit () ; 
  1195.       curcmd = 71 ; 
  1196.       curchr = 4066 + curval ; 
  1197.     } 
  1198.     if ( curcmd == 71 ) 
  1199.     {
  1200.       q = eqtb [ curchr ] .hh .v.RH ; 
  1201.       if ( q == 0 ) 
  1202.       if ( ( a >= 4 ) ) 
  1203.       geqdefine ( p , 100 , 0 ) ; 
  1204.       else eqdefine ( p , 100 , 0 ) ; 
  1205.       else { 
  1206.         incr ( mem [(long) q ] .hh .v.LH ) ; 
  1207.         if ( ( a >= 4 ) ) 
  1208.         geqdefine ( p , 110 , q ) ; 
  1209.         else eqdefine ( p , 110 , q ) ; 
  1210.       } 
  1211.       goto lab30 ; 
  1212.     } 
  1213.       } 
  1214.       backinput () ; 
  1215.       curcs = q ; 
  1216.       q = scantoks ( false , false ) ; 
  1217.       if ( mem [(long) defref ] .hh .v.RH == 0 ) 
  1218.       {
  1219.     if ( ( a >= 4 ) ) 
  1220.     geqdefine ( p , 100 , 0 ) ; 
  1221.     else eqdefine ( p , 100 , 0 ) ; 
  1222.     {
  1223.       mem [(long) defref ] .hh .v.RH = avail ; 
  1224.       avail = defref ; 
  1225.  
  1226. #ifdef STAT
  1227.       decr ( dynused ) ; 
  1228. #endif /* STAT */
  1229.     } 
  1230.       } 
  1231.       else { 
  1232.     if ( p == 4057 ) 
  1233.     {
  1234.       mem [(long) q ] .hh .v.RH = getavail () ; 
  1235.       q = mem [(long) q ] .hh .v.RH ; 
  1236.       mem [(long) q ] .hh .v.LH = 637 ; 
  1237.       q = getavail () ; 
  1238.       mem [(long) q ] .hh .v.LH = 379 ; 
  1239.       mem [(long) q ] .hh .v.RH = mem [(long) defref ] .hh .v.RH ; 
  1240.       mem [(long) defref ] .hh .v.RH = q ; 
  1241.     } 
  1242.     if ( ( a >= 4 ) ) 
  1243.     geqdefine ( p , 110 , defref ) ; 
  1244.     else eqdefine ( p , 110 , defref ) ; 
  1245.       } 
  1246.     } 
  1247.     break ; 
  1248.   case 72 : 
  1249.     {
  1250.       p = curchr ; 
  1251.       scanoptional () ; 
  1252.       scanint () ; 
  1253.       if ( ( a >= 4 ) ) 
  1254.       geqworddefin ( p , curval ) ; 
  1255.       else eqworddefine ( p , curval ) ; 
  1256.     } 
  1257.     break ; 
  1258.   case 73 : 
  1259.     {
  1260.       p = curchr ; 
  1261.       scanoptional () ; 
  1262.       scandimen ( false , false , false ) ; 
  1263.       if ( ( a >= 4 ) ) 
  1264.       geqworddefin ( p , curval ) ; 
  1265.       else eqworddefine ( p , curval ) ; 
  1266.     } 
  1267.     break ; 
  1268.   case 74 : 
  1269.   case 75 : 
  1270.     {
  1271.       p = curchr ; 
  1272.       n = curcmd ; 
  1273.       scanoptional () ; 
  1274.       if ( n == 75 ) 
  1275.       scanglue ( 3 ) ; 
  1276.       else scanglue ( 2 ) ; 
  1277.       trapzeroglue () ; 
  1278.       if ( ( a >= 4 ) ) 
  1279.       geqdefine ( p , 116 , curval ) ; 
  1280.       else eqdefine ( p , 116 , curval ) ; 
  1281.     } 
  1282.     break ; 
  1283.   case 84 : 
  1284.     {
  1285.       if ( curchr == 4627 ) 
  1286.       n = 15 ; 
  1287.       else if ( curchr == 5139 ) 
  1288.       n = 32768 ; 
  1289.       else if ( curchr == 5011 ) 
  1290.       n = 32767 ; 
  1291.       else if ( curchr == 5573 ) 
  1292.       n = 16777215 ; 
  1293.       else n = 127 ; 
  1294.       p = curchr ; 
  1295.       scansevenbit () ; 
  1296.       p = p + curval ; 
  1297.       scanoptional () ; 
  1298.       scanint () ; 
  1299.       if ( ( ( curval < 0 ) && ( p < 5573 ) ) || ( curval > n ) ) 
  1300.       {
  1301.     {
  1302.       if ( interaction == 3 ) 
  1303.       wakeuptermin () ; 
  1304.       printnl ( 133 ) ; 
  1305.       print ( 1050 ) ; 
  1306.     } 
  1307.     printint ( curval ) ; 
  1308.     if ( p < 5573 ) 
  1309.     print ( 1051 ) ; 
  1310.     else print ( 1052 ) ; 
  1311.     printint ( n ) ; 
  1312.     {
  1313.       helpptr = 1 ; 
  1314.       helpline [ 0 ] = 1053 ; 
  1315.     } 
  1316.     error () ; 
  1317.     curval = 0 ; 
  1318.       } 
  1319.       if ( p < 5139 ) 
  1320.       if ( ( a >= 4 ) ) 
  1321.       geqdefine ( p , 119 , curval ) ; 
  1322.       else eqdefine ( p , 119 , curval ) ; 
  1323.       else if ( p < 5573 ) 
  1324.       if ( ( a >= 4 ) ) 
  1325.       geqdefine ( p , 119 , curval ) ; 
  1326.       else eqdefine ( p , 119 , curval ) ; 
  1327.       else if ( ( a >= 4 ) ) 
  1328.       geqworddefin ( p , curval ) ; 
  1329.       else eqworddefine ( p , curval ) ; 
  1330.     } 
  1331.     break ; 
  1332.   case 85 : 
  1333.     {
  1334.       p = curchr ; 
  1335.       scanfourbiti () ; 
  1336.       p = p + curval ; 
  1337.       scanoptional () ; 
  1338.       scanfontiden () ; 
  1339.       if ( ( a >= 4 ) ) 
  1340.       geqdefine ( p , 119 , curval ) ; 
  1341.       else eqdefine ( p , 119 , curval ) ; 
  1342.     } 
  1343.     break ; 
  1344.   case 88 : 
  1345.   case 89 : 
  1346.   case 90 : 
  1347.   case 91 : 
  1348.     doregisterco ( a ) ; 
  1349.     break ; 
  1350.   case 97 : 
  1351.     {
  1352.       scaneightbit () ; 
  1353.       if ( ( a >= 4 ) ) 
  1354.       savestack [ saveptr + 0 ] .cint = 1073742080 + curval ; 
  1355.       else savestack [ saveptr + 0 ] .cint = 1073741824 + curval ; 
  1356.       scanoptional () ; 
  1357.       scanbox () ; 
  1358.     } 
  1359.     break ; 
  1360.   case 78 : 
  1361.     alteraux () ; 
  1362.     break ; 
  1363.   case 79 : 
  1364.     alterprevgra () ; 
  1365.     break ; 
  1366.   case 80 : 
  1367.     alterpagesof () ; 
  1368.     break ; 
  1369.   case 81 : 
  1370.     alterinteger () ; 
  1371.     break ; 
  1372.   case 82 : 
  1373.     alterboxdime () ; 
  1374.     break ; 
  1375.   case 83 : 
  1376.     {
  1377.       scanoptional () ; 
  1378.       scanint () ; 
  1379.       n = curval ; 
  1380.       if ( n <= 0 ) 
  1381.       p = 0 ; 
  1382.       else { 
  1383.     p = getnode ( 2 * n + 1 ) ; 
  1384.     mem [(long) p ] .hh .v.LH = n ; 
  1385.     for ( j = 1 ; j <= n ; j ++ ) 
  1386.     {
  1387.       scandimen ( false , false , false ) ; 
  1388.       mem [(long) p + 2 * j - 1 ] .cint = curval ; 
  1389.       scandimen ( false , false , false ) ; 
  1390.       mem [(long) p + 2 * j ] .cint = curval ; 
  1391.     } 
  1392.       } 
  1393.       if ( ( a >= 4 ) ) 
  1394.       geqdefine ( 4056 , 117 , p ) ; 
  1395.       else eqdefine ( 4056 , 117 , p ) ; 
  1396.     } 
  1397.     break ; 
  1398.   case 98 : 
  1399.     if ( curchr == 1 ) 
  1400.     {
  1401.  
  1402. #ifdef INITEX
  1403.       newpatterns () ; 
  1404.       goto lab30 ; 
  1405. #endif /* INITEX */
  1406.       {
  1407.     if ( interaction == 3 ) 
  1408.     wakeuptermin () ; 
  1409.     printnl ( 133 ) ; 
  1410.     print ( 1062 ) ; 
  1411.       } 
  1412.       helpptr = 0 ; 
  1413.       error () ; 
  1414.       do { gettoken () ; 
  1415.       } while ( ! ( curcmd == 2 ) ) ; 
  1416.       return ; 
  1417.     } 
  1418.     else { 
  1419.       newhyphexcep () ; 
  1420.       goto lab30 ; 
  1421.     } 
  1422.     break ; 
  1423.   case 76 : 
  1424.     {
  1425.       findfontdime ( true ) ; 
  1426.       k = curval ; 
  1427.       scanoptional () ; 
  1428.       scandimen ( false , false , false ) ; 
  1429.       fontinfo [ k ] .cint = curval ; 
  1430.     } 
  1431.     break ; 
  1432.   case 77 : 
  1433.     {
  1434.       n = curchr ; 
  1435.       scanfontiden () ; 
  1436.       f = curval ; 
  1437.       scanoptional () ; 
  1438.       scanint () ; 
  1439.       if ( n == 0 ) 
  1440.       hyphenchar [ f ] = curval ; 
  1441.       else skewchar [ f ] = curval ; 
  1442.     } 
  1443.     break ; 
  1444.   case 87 : 
  1445.     newfont ( a ) ; 
  1446.     break ; 
  1447.   case 99 : 
  1448.     newinteracti () ; 
  1449.     break ; 
  1450.   default : 
  1451.     confusion ( 1026 ) ; 
  1452.     break ; 
  1453.   } 
  1454.   lab30: if ( aftertoken != 0 ) 
  1455.   {
  1456.     curtok = aftertoken ; 
  1457.     backinput () ; 
  1458.     aftertoken = 0 ; 
  1459.   } 
  1460. } 
  1461. doassignment () { /* 10 */ r_doassignment 
  1462.   while ( true ) { 
  1463.     do { getxtoken () ; 
  1464.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1465.     if ( curcmd <= 69 ) 
  1466.     return ; 
  1467.     prefixedcomm () ; 
  1468.   } 
  1469. } 
  1470. openorclosei () { r_openorclosei 
  1471.   quarterword c ; 
  1472.   quarterword n ; 
  1473.   c = curchr ; 
  1474.   scanfourbiti () ; 
  1475.   n = curval ; 
  1476.   if ( readopen [ n ] != 2 ) 
  1477.   {
  1478.     aclose ( readfile [ n ] ) ; 
  1479.     readopen [ n ] = 2 ; 
  1480.   } 
  1481.   if ( c != 0 ) 
  1482.   {
  1483.     scanoptional () ; 
  1484.     scanfilename () ; 
  1485.     if ( curext == 206 ) 
  1486.     curext = 644 ; 
  1487.     packfilename ( curname , curarea , curext ) ; 
  1488.     if ( aopenin ( readfile [ n ] , readpathspec ) ) 
  1489.     readopen [ n ] = 1 ; 
  1490.   } 
  1491. } 
  1492. issuemessage () { r_issuemessage 
  1493.   quarterword oldsetting ; 
  1494.   quarterword c ; 
  1495.   strnumber s ; 
  1496.   c = curchr ; 
  1497.   mem [(long) memtop - 12 ] .hh .v.RH = scantoks ( false , true ) ; 
  1498.   oldsetting = selector ; 
  1499.   selector = 21 ; 
  1500.   tokenshow ( defref ) ; 
  1501.   selector = oldsetting ; 
  1502.   flushlist ( defref ) ; 
  1503.   {
  1504.     if ( poolptr + 1 > poolsize ) 
  1505.     overflow ( 128 , poolsize - initpoolptr ) ; 
  1506.   } 
  1507.   s = makestring () ; 
  1508.   if ( c == 0 ) 
  1509.   {
  1510.     if ( termoffset + ( strstart [ s + 1 ] - strstart [ s ] ) > maxprintline - 
  1511.     2 ) 
  1512.     println () ; 
  1513.     else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  1514.     printchar ( 32 ) ; 
  1515.     print ( s ) ; 
  1516.     termflush ( output ) ; 
  1517.   } 
  1518.   else { 
  1519.     {
  1520.       if ( interaction == 3 ) 
  1521.       wakeuptermin () ; 
  1522.       printnl ( 133 ) ; 
  1523.       print ( s ) ; 
  1524.     } 
  1525.     if ( eqtb [ 4065 ] .hh .v.RH != 0 ) 
  1526.     useerrhelp = true ; 
  1527.     else if ( longhelpseen ) 
  1528.     {
  1529.       helpptr = 1 ; 
  1530.       helpline [ 0 ] = 1078 ; 
  1531.     } 
  1532.     else { 
  1533.       if ( interaction < 3 ) 
  1534.       longhelpseen = true ; 
  1535.       {
  1536.     helpptr = 4 ; 
  1537.     helpline [ 3 ] = 1079 ; 
  1538.     helpline [ 2 ] = 1080 ; 
  1539.     helpline [ 1 ] = 1081 ; 
  1540.     helpline [ 0 ] = 1082 ; 
  1541.       } 
  1542.     } 
  1543.     error () ; 
  1544.     useerrhelp = false ; 
  1545.   } 
  1546.   {
  1547.     decr ( strptr ) ; 
  1548.     poolptr = strstart [ strptr ] ; 
  1549.   } 
  1550. } 
  1551. shiftcase () { r_shiftcase 
  1552.   halfword b ; 
  1553.   halfword p ; 
  1554.   halfword t ; 
  1555.   eightbits c ; 
  1556.   b = curchr ; 
  1557.   p = scantoks ( false , false ) ; 
  1558.   p = mem [(long) defref ] .hh .v.RH ; 
  1559.   while ( p != 0 ) { 
  1560.     t = mem [(long) p ] .hh .v.LH ; 
  1561.     if ( t < 4225 ) 
  1562.     {
  1563.       if ( t >= 4096 ) 
  1564.       t = t - 1 ; 
  1565.       c = t % 256 ; 
  1566.       if ( c < 128 ) 
  1567.       if ( eqtb [ b + c ] .hh .v.RH != 0 ) 
  1568.       t = 256 * ( t / 256 ) + eqtb [ b + c ] .hh .v.RH ; 
  1569.       if ( t >= 4096 ) 
  1570.       mem [(long) p ] .hh .v.LH = t + 1 ; 
  1571.       else mem [(long) p ] .hh .v.LH = t ; 
  1572.     } 
  1573.     p = mem [(long) p ] .hh .v.RH ; 
  1574.   } 
  1575.   begintokenli ( mem [(long) defref ] .hh .v.RH , 3 ) ; 
  1576.   {
  1577.     mem [(long) defref ] .hh .v.RH = avail ; 
  1578.     avail = defref ; 
  1579.  
  1580. #ifdef STAT
  1581.     decr ( dynused ) ; 
  1582. #endif /* STAT */
  1583.   } 
  1584. } 
  1585. showwhatever () { /* 50 */ r_showwhatever 
  1586.   halfword p ; 
  1587.   switch ( curchr ) 
  1588.   {case 3 : 
  1589.     {
  1590.       begindiagnos () ; 
  1591.       showactiviti () ; 
  1592.     } 
  1593.     break ; 
  1594.   case 1 : 
  1595.     {
  1596.       scaneightbit () ; 
  1597.       begindiagnos () ; 
  1598.       printnl ( 1100 ) ; 
  1599.       printint ( curval ) ; 
  1600.       printchar ( 61 ) ; 
  1601.       if ( eqtb [ 4322 + curval ] .hh .v.RH == 0 ) 
  1602.       print ( 275 ) ; 
  1603.       else showbox ( eqtb [ 4322 + curval ] .hh .v.RH ) ; 
  1604.     } 
  1605.     break ; 
  1606.   case 0 : 
  1607.     {
  1608.       gettoken () ; 
  1609.       if ( interaction == 3 ) 
  1610.       wakeuptermin () ; 
  1611.       printnl ( 1094 ) ; 
  1612.       if ( curcs != 0 ) 
  1613.       {
  1614.     sprintcs ( curcs ) ; 
  1615.     printchar ( 61 ) ; 
  1616.       } 
  1617.       printmeaning () ; 
  1618.       goto lab50 ; 
  1619.     } 
  1620.     break ; 
  1621.   default : 
  1622.     {
  1623.       p = thetoks () ; 
  1624.       if ( interaction == 3 ) 
  1625.       wakeuptermin () ; 
  1626.       printnl ( 1094 ) ; 
  1627.       tokenshow ( memtop - 3 ) ; 
  1628.       flushlist ( mem [(long) memtop - 3 ] .hh .v.RH ) ; 
  1629.       goto lab50 ; 
  1630.     } 
  1631.     break ; 
  1632.   } 
  1633.   enddiagnosti ( true ) ; 
  1634.   {
  1635.     if ( interaction == 3 ) 
  1636.     wakeuptermin () ; 
  1637.     printnl ( 133 ) ; 
  1638.     print ( 1101 ) ; 
  1639.   } 
  1640.   if ( selector == 19 ) 
  1641.   if ( eqtb [ 5296 ] .cint <= 0 ) 
  1642.   {
  1643.     selector = 17 ; 
  1644.     print ( 1102 ) ; 
  1645.     selector = 19 ; 
  1646.   } 
  1647.   lab50: if ( interaction < 3 ) 
  1648.   {
  1649.     helpptr = 0 ; 
  1650.     decr ( errorcount ) ; 
  1651.   } 
  1652.   else if ( eqtb [ 5296 ] .cint > 0 ) 
  1653.   {
  1654.     {
  1655.       helpptr = 3 ; 
  1656.       helpline [ 2 ] = 1089 ; 
  1657.       helpline [ 1 ] = 1090 ; 
  1658.       helpline [ 0 ] = 1091 ; 
  1659.     } 
  1660.   } 
  1661.   else { 
  1662.     {
  1663.       helpptr = 5 ; 
  1664.       helpline [ 4 ] = 1089 ; 
  1665.       helpline [ 3 ] = 1090 ; 
  1666.       helpline [ 2 ] = 1091 ; 
  1667.       helpline [ 1 ] = 1092 ; 
  1668.       helpline [ 0 ] = 1093 ; 
  1669.     } 
  1670.   } 
  1671.   error () ; 
  1672. } 
  1673.  
  1674. #ifdef INITEX
  1675. storefmtfile () { /* 41 42 31 32 */ r_storefmtfile 
  1676.   integer j, k, l ; 
  1677.   halfword p, q ; 
  1678.   integer x ; 
  1679.   fourquarters w ; 
  1680.   if ( saveptr != 0 ) 
  1681.   {
  1682.     {
  1683.       if ( interaction == 3 ) 
  1684.       wakeuptermin () ; 
  1685.       printnl ( 133 ) ; 
  1686.       print ( 1104 ) ; 
  1687.     } 
  1688.     {
  1689.       helpptr = 1 ; 
  1690.       helpline [ 0 ] = 1105 ; 
  1691.     } 
  1692.     {
  1693.       if ( interaction == 3 ) 
  1694.       interaction = 2 ; 
  1695.       error () ; 
  1696.  
  1697. #ifdef DEBUG
  1698.       if ( interaction > 0 ) 
  1699.       debughelp () ; 
  1700. #endif /* DEBUG */
  1701.       history = 3 ; 
  1702.       jumpout () ; 
  1703.     } 
  1704.   } 
  1705.   selector = 21 ; 
  1706.   print ( 1116 ) ; 
  1707.   print ( jobname ) ; 
  1708.   printchar ( 32 ) ; 
  1709.   printint ( eqtb [ 5290 ] .cint % 100 ) ; 
  1710.   printchar ( 46 ) ; 
  1711.   printint ( eqtb [ 5289 ] .cint ) ; 
  1712.   printchar ( 46 ) ; 
  1713.   printint ( eqtb [ 5288 ] .cint ) ; 
  1714.   printchar ( 41 ) ; 
  1715.   if ( interaction == 0 ) 
  1716.   selector = 18 ; 
  1717.   else selector = 19 ; 
  1718.   {
  1719.     if ( poolptr + 1 > poolsize ) 
  1720.     overflow ( 128 , poolsize - initpoolptr ) ; 
  1721.   } 
  1722.   formatident = makestring () ; 
  1723.   packjobname ( 1117 ) ; 
  1724.   while ( ! wopenout ( fmtfile ) ) promptfilena ( 1118 , 1117 ) ; 
  1725.   printnl ( 1119 ) ; 
  1726.   print ( wmakenamestr ( fmtfile ) ) ; 
  1727.   {
  1728.     decr ( strptr ) ; 
  1729.     poolptr = strstart [ strptr ] ; 
  1730.   } 
  1731.   printnl ( formatident ) ; 
  1732.   putfmtint ( 13634946 ) ; 
  1733.   putfmtint ( 0 ) ; 
  1734.   putfmtint ( memtop ) ; 
  1735.   putfmtint ( 5976 ) ; 
  1736.   putfmtint ( 2551 ) ; 
  1737.   putfmtint ( 307 ) ; 
  1738.   putfmtint ( poolptr ) ; 
  1739.   putfmtint ( strptr ) ; 
  1740.   dumpthings ( strstart [ 0 ] , strptr + 1 ) ; 
  1741.   dumpthings ( strpool [ 0 ] , poolptr ) ; 
  1742.   println () ; 
  1743.   printint ( strptr ) ; 
  1744.   print ( 1106 ) ; 
  1745.   printint ( poolptr ) ; 
  1746.   sortavail () ; 
  1747.   varused = 0 ; 
  1748.   putfmtint ( lomemmax ) ; 
  1749.   putfmtint ( rover ) ; 
  1750.   p = 0 ; 
  1751.   q = rover ; 
  1752.   x = 0 ; 
  1753.   do { dumpthings ( mem [(long) p ] , q + 2 - p ) ; 
  1754.     x = x + q + 2 - p ; 
  1755.     varused = varused + q - p ; 
  1756.     p = q + mem [(long) q ] .hh .v.LH ; 
  1757.     q = mem [(long) q + 1 ] .hh .v.RH ; 
  1758.   } while ( ! ( q == rover ) ) ; 
  1759.   varused = varused + lomemmax - p ; 
  1760.   dynused = memend + 1 - himemmin ; 
  1761.   dumpthings ( mem [(long) p ] , lomemmax + 1 - p ) ; 
  1762.   x = x + lomemmax + 1 - p ; 
  1763.   putfmtint ( himemmin ) ; 
  1764.   putfmtint ( avail ) ; 
  1765.   dumpthings ( mem [(long) himemmin ] , memend + 1 - himemmin ) ; 
  1766.   x = x + memend + 1 - himemmin ; 
  1767.   p = avail ; 
  1768.   while ( p != 0 ) { 
  1769.     decr ( dynused ) ; 
  1770.     p = mem [(long) p ] .hh .v.RH ; 
  1771.   } 
  1772.   putfmtint ( varused ) ; 
  1773.   putfmtint ( dynused ) ; 
  1774.   println () ; 
  1775.   printint ( x ) ; 
  1776.   print ( 1107 ) ; 
  1777.   printint ( varused ) ; 
  1778.   printchar ( 38 ) ; 
  1779.   printint ( dynused ) ; 
  1780.   k = 1 ; 
  1781.   do { j = k ; 
  1782.     while ( j < 5266 ) { 
  1783.       if ( ( eqtb [ j ] .hh .v.RH == eqtb [ j + 1 ] .hh .v.RH ) && ( eqtb [ j 
  1784.       ] .hh.b0 == eqtb [ j + 1 ] .hh.b0 ) && ( eqtb [ j ] .hh.b1 == eqtb [ j + 
  1785.       1 ] .hh.b1 ) ) 
  1786.       goto lab41 ; 
  1787.       incr ( j ) ; 
  1788.     } 
  1789.     l = 5267 ; 
  1790.     goto lab31 ; 
  1791.     lab41: incr ( j ) ; 
  1792.     l = j ; 
  1793.     while ( j < 5266 ) { 
  1794.       if ( ( eqtb [ j ] .hh .v.RH != eqtb [ j + 1 ] .hh .v.RH ) || ( eqtb [ j 
  1795.       ] .hh.b0 != eqtb [ j + 1 ] .hh.b0 ) || ( eqtb [ j ] .hh.b1 != eqtb [ j + 
  1796.       1 ] .hh.b1 ) ) 
  1797.       goto lab31 ; 
  1798.       incr ( j ) ; 
  1799.     } 
  1800.     lab31: putfmtint ( l - k ) ; 
  1801.     dumpthings ( eqtb [ k ] , l - k ) ; 
  1802.     k = j + 1 ; 
  1803.     putfmtint ( k - l ) ; 
  1804.   } while ( ! ( k == 5267 ) ) ; 
  1805.   do { j = k ; 
  1806.     while ( j < 5976 ) { 
  1807.       if ( eqtb [ j ] .cint == eqtb [ j + 1 ] .cint ) 
  1808.       goto lab42 ; 
  1809.       incr ( j ) ; 
  1810.     } 
  1811.     l = 5977 ; 
  1812.     goto lab32 ; 
  1813.     lab42: incr ( j ) ; 
  1814.     l = j ; 
  1815.     while ( j < 5976 ) { 
  1816.       if ( eqtb [ j ] .cint != eqtb [ j + 1 ] .cint ) 
  1817.       goto lab32 ; 
  1818.       incr ( j ) ; 
  1819.     } 
  1820.     lab32: putfmtint ( l - k ) ; 
  1821.     dumpthings ( eqtb [ k ] , l - k ) ; 
  1822.     k = j + 1 ; 
  1823.     putfmtint ( k - l ) ; 
  1824.   } while ( ! ( k > 5976 ) ) ; 
  1825.   putfmtint ( parloc ) ; 
  1826.   putfmtint ( writeloc ) ; 
  1827.   putfmtint ( hashused ) ; 
  1828.   cscount = 3257 - hashused ; 
  1829.   for ( p = 258 ; p <= hashused ; p ++ ) 
  1830.   if ( hash [ p ] .v.RH != 0 ) 
  1831.   {
  1832.     putfmtint ( p ) ; 
  1833.     putfmthh ( hash [ p ] ) ; 
  1834.     incr ( cscount ) ; 
  1835.   } 
  1836.   dumpthings ( hash [ hashused + 1 ] , 3524 - hashused ) ; 
  1837.   putfmtint ( cscount ) ; 
  1838.   println () ; 
  1839.   printint ( cscount ) ; 
  1840.   print ( 1108 ) ; 
  1841.   putfmtint ( fmemptr ) ; 
  1842.   dumpthings ( fontinfo [ 0 ] , fmemptr ) ; 
  1843.   putfmtint ( fontptr ) ; 
  1844.   dumpthings ( fontsize [ 0 ] , fontptr + 1 ) ; 
  1845.   dumpthings ( fontdsize [ 0 ] , fontptr + 1 ) ; 
  1846.   dumpthings ( fontparams [ 0 ] , fontptr + 1 ) ; 
  1847.   dumpthings ( hyphenchar [ 0 ] , fontptr + 1 ) ; 
  1848.   dumpthings ( skewchar [ 0 ] , fontptr + 1 ) ; 
  1849.   dumpthings ( fontname [ 0 ] , fontptr + 1 ) ; 
  1850.   dumpthings ( fontarea [ 0 ] , fontptr + 1 ) ; 
  1851.   dumpthings ( fontbc [ 0 ] , fontptr + 1 ) ; 
  1852.   dumpthings ( fontec [ 0 ] , fontptr + 1 ) ; 
  1853.   dumpthings ( charbase [ 0 ] , fontptr + 1 ) ; 
  1854.   dumpthings ( widthbase [ 0 ] , fontptr + 1 ) ; 
  1855.   dumpthings ( heightbase [ 0 ] , fontptr + 1 ) ; 
  1856.   dumpthings ( depthbase [ 0 ] , fontptr + 1 ) ; 
  1857.   dumpthings ( italicbase [ 0 ] , fontptr + 1 ) ; 
  1858.   dumpthings ( ligkernbase [ 0 ] , fontptr + 1 ) ; 
  1859.   dumpthings ( kernbase [ 0 ] , fontptr + 1 ) ; 
  1860.   dumpthings ( extenbase [ 0 ] , fontptr + 1 ) ; 
  1861.   dumpthings ( parambase [ 0 ] , fontptr + 1 ) ; 
  1862.   for ( k = 0 ; k <= fontptr ; k ++ ) 
  1863.   {
  1864.     printnl ( 1109 ) ; 
  1865.     printesc ( hash [ 3268 + k ] .v.RH ) ; 
  1866.     printchar ( 61 ) ; 
  1867.     printfilenam ( fontname [ k ] , fontarea [ k ] , 206 ) ; 
  1868.     if ( fontsize [ k ] != fontdsize [ k ] ) 
  1869.     {
  1870.       print ( 598 ) ; 
  1871.       printscaled ( fontsize [ k ] ) ; 
  1872.       print ( 262 ) ; 
  1873.     } 
  1874.   } 
  1875.   println () ; 
  1876.   printint ( fmemptr - 7 ) ; 
  1877.   print ( 1110 ) ; 
  1878.   printint ( fontptr - 0 ) ; 
  1879.   print ( 1111 ) ; 
  1880.   if ( fontptr != 1 ) 
  1881.   printchar ( 115 ) ; 
  1882.   putfmtint ( hyphcount ) ; 
  1883.   for ( k = 0 ; k <= 307 ; k ++ ) 
  1884.   if ( hyphword [ k ] != 0 ) 
  1885.   {
  1886.     putfmtint ( k ) ; 
  1887.     putfmtint ( hyphword [ k ] ) ; 
  1888.     putfmtint ( hyphlist [ k ] ) ; 
  1889.   } 
  1890.   putfmtint ( triemax ) ; 
  1891.   dumpthings ( trie [ 0 ] , triemax + 1 ) ; 
  1892.   putfmtint ( trieopptr ) ; 
  1893.   dumpthings ( hyfdistance [ 1 ] , trieopptr - 0 ) ; 
  1894.   dumpthings ( hyfnum [ 1 ] , trieopptr - 0 ) ; 
  1895.   dumpthings ( hyfnext [ 1 ] , trieopptr - 0 ) ; 
  1896.   println () ; 
  1897.   printint ( hyphcount ) ; 
  1898.   print ( 1112 ) ; 
  1899.   if ( hyphcount != 1 ) 
  1900.   printchar ( 115 ) ; 
  1901.   printnl ( 1113 ) ; 
  1902.   printint ( triemax ) ; 
  1903.   print ( 1114 ) ; 
  1904.   printint ( trieopptr ) ; 
  1905.   print ( 1115 ) ; 
  1906.   if ( trieopptr != 1 ) 
  1907.   printchar ( 115 ) ; 
  1908.   putfmtint ( interaction ) ; 
  1909.   putfmtint ( formatident ) ; 
  1910.   putfmtint ( 69069 ) ; 
  1911.   eqtb [ 5298 ] .cint = 0 ; 
  1912.   wclose ( fmtfile ) ; 
  1913. } 
  1914. #endif /* INITEX */
  1915. znewwhatsit ( s , w ) 
  1916. smallnumber s ; 
  1917. smallnumber w ; 
  1918. {r_newwhatsit 
  1919.   halfword p ; 
  1920.   p = getnode ( w ) ; 
  1921.   mem [(long) p ] .hh.b0 = 8 ; 
  1922.   mem [(long) p ] .hh.b1 = s ; 
  1923.   mem [(long) curlist .tailfield ] .hh .v.RH = p ; 
  1924.   curlist .tailfield = p ; 
  1925. } 
  1926. znewwritewhat ( w ) 
  1927. smallnumber w ; 
  1928. {r_newwritewhat 
  1929.   newwhatsit ( curchr , w ) ; 
  1930.   if ( w != 2 ) 
  1931.   scanfourbiti () ; 
  1932.   else { 
  1933.     scanint () ; 
  1934.     if ( curval < 0 ) 
  1935.     curval = 17 ; 
  1936.     else if ( curval > 15 ) 
  1937.     curval = 16 ; 
  1938.   } 
  1939.   mem [(long) curlist .tailfield + 1 ] .hh .v.LH = curval ; 
  1940. } 
  1941. doextension () { r_doextension 
  1942.   integer i, j, k ; 
  1943.   halfword p, q, r ; 
  1944.   switch ( curchr ) 
  1945.   {case 0 : 
  1946.     {
  1947.       newwritewhat ( 3 ) ; 
  1948.       scanoptional () ; 
  1949.       scanfilename () ; 
  1950.       mem [(long) curlist .tailfield + 1 ] .hh .v.RH = curname ; 
  1951.       mem [(long) curlist .tailfield + 2 ] .hh .v.LH = curarea ; 
  1952.       mem [(long) curlist .tailfield + 2 ] .hh .v.RH = curext ; 
  1953.     } 
  1954.     break ; 
  1955.   case 1 : 
  1956.     {
  1957.       k = curcs ; 
  1958.       newwritewhat ( 2 ) ; 
  1959.       curcs = k ; 
  1960.       p = scantoks ( false , false ) ; 
  1961.       mem [(long) curlist .tailfield + 1 ] .hh .v.RH = defref ; 
  1962.     } 
  1963.     break ; 
  1964.   case 2 : 
  1965.     {
  1966.       newwritewhat ( 2 ) ; 
  1967.       mem [(long) curlist .tailfield + 1 ] .hh .v.RH = 0 ; 
  1968.     } 
  1969.     break ; 
  1970.   case 3 : 
  1971.     {
  1972.       newwhatsit ( 3 , 2 ) ; 
  1973.       mem [(long) curlist .tailfield + 1 ] .hh .v.LH = 0 ; 
  1974.       p = scantoks ( false , true ) ; 
  1975.       mem [(long) curlist .tailfield + 1 ] .hh .v.RH = defref ; 
  1976.     } 
  1977.     break ; 
  1978.   case 4 : 
  1979.     {
  1980.       getxtoken () ; 
  1981.       if ( ( curcmd == 59 ) && ( curchr <= 2 ) ) 
  1982.       {
  1983.     p = curlist .tailfield ; 
  1984.     doextension () ; 
  1985.     outwhat ( curlist .tailfield ) ; 
  1986.     flushnodelis ( curlist .tailfield ) ; 
  1987.     curlist .tailfield = p ; 
  1988.     mem [(long) p ] .hh .v.RH = 0 ; 
  1989.       } 
  1990.       else backinput () ; 
  1991.     } 
  1992.     break ; 
  1993.   default : 
  1994.     confusion ( 1134 ) ; 
  1995.     break ; 
  1996.   } 
  1997. } 
  1998. handlerightb () { r_handlerightb 
  1999.   halfword p, q ; 
  2000.   scaled d ; 
  2001.   integer f ; 
  2002.   switch ( curgroup ) 
  2003.   {case 1 : 
  2004.     unsave () ; 
  2005.     break ; 
  2006.   case 0 : 
  2007.     {
  2008.       {
  2009.     if ( interaction == 3 ) 
  2010.     wakeuptermin () ; 
  2011.     printnl ( 133 ) ; 
  2012.     print ( 892 ) ; 
  2013.       } 
  2014.       {
  2015.     helpptr = 2 ; 
  2016.     helpline [ 1 ] = 893 ; 
  2017.     helpline [ 0 ] = 894 ; 
  2018.       } 
  2019.       error () ; 
  2020.     } 
  2021.     break ; 
  2022.   case 14 : 
  2023.   case 15 : 
  2024.   case 16 : 
  2025.     extrarightbr () ; 
  2026.     break ; 
  2027.   case 2 : 
  2028.     package ( 0 ) ; 
  2029.     break ; 
  2030.   case 3 : 
  2031.     {
  2032.       adjusttail = memtop - 5 ; 
  2033.       package ( 0 ) ; 
  2034.     } 
  2035.     break ; 
  2036.   case 4 : 
  2037.     {
  2038.       endgraf () ; 
  2039.       package ( 0 ) ; 
  2040.     } 
  2041.     break ; 
  2042.   case 5 : 
  2043.     {
  2044.       endgraf () ; 
  2045.       package ( 4 ) ; 
  2046.     } 
  2047.     break ; 
  2048.   case 11 : 
  2049.     {
  2050.       endgraf () ; 
  2051.       q = eqtb [ 3536 ] .hh .v.RH ; 
  2052.       incr ( mem [(long) q ] .hh .v.RH ) ; 
  2053.       d = eqtb [ 5707 ] .cint ; 
  2054.       f = eqtb [ 5309 ] .cint ; 
  2055.       unsave () ; 
  2056.       decr ( saveptr ) ; 
  2057.       p = vpackage ( mem [(long) curlist .headfield ] .hh .v.RH , 0 , 1 , 1073741823 
  2058.       ) ; 
  2059.       popnest () ; 
  2060.       if ( savestack [ saveptr + 0 ] .cint < 255 ) 
  2061.       {
  2062.     {
  2063.       mem [(long) curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  2064.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  2065.     } 
  2066.     mem [(long) curlist .tailfield ] .hh.b0 = 3 ; 
  2067.     mem [(long) curlist .tailfield ] .hh.b1 = savestack [ saveptr + 0 ] .cint ; 
  2068.     mem [(long) curlist .tailfield + 3 ] .cint = mem [(long) p + 3 ] .cint + mem [(long) p + 
  2069.     2 ] .cint ; 
  2070.     mem [(long) curlist .tailfield + 4 ] .hh .v.LH = mem [(long) p + 5 ] .hh .v.RH ; 
  2071.     mem [(long) curlist .tailfield + 4 ] .hh .v.RH = q ; 
  2072.     mem [(long) curlist .tailfield + 2 ] .cint = d ; 
  2073.     mem [(long) curlist .tailfield + 1 ] .cint = f ; 
  2074.       } 
  2075.       else { 
  2076.     {
  2077.       mem [(long) curlist .tailfield ] .hh .v.RH = getnode ( 2 ) ; 
  2078.       curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  2079.     } 
  2080.     mem [(long) curlist .tailfield ] .hh.b0 = 5 ; 
  2081.     mem [(long) curlist .tailfield ] .hh.b1 = 0 ; 
  2082.     mem [(long) curlist .tailfield + 1 ] .cint = mem [(long) p + 5 ] .hh .v.RH ; 
  2083.     deletegluere ( q ) ; 
  2084.       } 
  2085.       freenode ( p , 7 ) ; 
  2086.       if ( nestptr == 0 ) 
  2087.       buildpage () ; 
  2088.     } 
  2089.     break ; 
  2090.   case 8 : 
  2091.     {
  2092.       if ( curinput .locfield != 0 ) 
  2093.       {
  2094.     {
  2095.       if ( interaction == 3 ) 
  2096.       wakeuptermin () ; 
  2097.       printnl ( 133 ) ; 
  2098.       print ( 858 ) ; 
  2099.     } 
  2100.     {
  2101.       helpptr = 2 ; 
  2102.       helpline [ 1 ] = 859 ; 
  2103.       helpline [ 0 ] = 860 ; 
  2104.     } 
  2105.     error () ; 
  2106.     do { gettoken () ; 
  2107.     } while ( ! ( curinput .locfield == 0 ) ) ; 
  2108.       } 
  2109.       endtokenlist () ; 
  2110.       endgraf () ; 
  2111.       unsave () ; 
  2112.       outputactive = false ; 
  2113.       insertpenalt = 0 ; 
  2114.       if ( eqtb [ 4577 ] .hh .v.RH != 0 ) 
  2115.       {
  2116.     {
  2117.       if ( interaction == 3 ) 
  2118.       wakeuptermin () ; 
  2119.       printnl ( 133 ) ; 
  2120.       print ( 861 ) ; 
  2121.     } 
  2122.     printesc ( 274 ) ; 
  2123.     printint ( 255 ) ; 
  2124.     {
  2125.       helpptr = 3 ; 
  2126.       helpline [ 2 ] = 862 ; 
  2127.       helpline [ 1 ] = 863 ; 
  2128.       helpline [ 0 ] = 864 ; 
  2129.     } 
  2130.     boxerror ( 255 ) ; 
  2131.       } 
  2132.       if ( curlist .tailfield != curlist .headfield ) 
  2133.       {
  2134.     mem [(long) pagetail ] .hh .v.RH = mem [(long) curlist .headfield ] .hh .v.RH ; 
  2135.     pagetail = curlist .tailfield ; 
  2136.       } 
  2137.       if ( mem [(long) memtop - 2 ] .hh .v.RH != 0 ) 
  2138.       {
  2139.     if ( mem [(long) memtop - 1 ] .hh .v.RH == 0 ) 
  2140.     nest [ 0 ] .tailfield = pagetail ; 
  2141.     mem [(long) pagetail ] .hh .v.RH = mem [(long) memtop - 1 ] .hh .v.RH ; 
  2142.     mem [(long) memtop - 1 ] .hh .v.RH = mem [(long) memtop - 2 ] .hh .v.RH ; 
  2143.     mem [(long) memtop - 2 ] .hh .v.RH = 0 ; 
  2144.     pagetail = memtop - 2 ; 
  2145.       } 
  2146.       popnest () ; 
  2147.       buildpage () ; 
  2148.     } 
  2149.     break ; 
  2150.   case 10 : 
  2151.     builddiscret () ; 
  2152.     break ; 
  2153.   case 6 : 
  2154.     {
  2155.       backinput () ; 
  2156.       curtok = 7355 ; 
  2157.       {
  2158.     if ( interaction == 3 ) 
  2159.     wakeuptermin () ; 
  2160.     printnl ( 133 ) ; 
  2161.     print ( 483 ) ; 
  2162.       } 
  2163.       printesc ( 752 ) ; 
  2164.       print ( 484 ) ; 
  2165.       {
  2166.     helpptr = 1 ; 
  2167.     helpline [ 0 ] = 973 ; 
  2168.       } 
  2169.       inserror () ; 
  2170.     } 
  2171.     break ; 
  2172.   case 7 : 
  2173.     {
  2174.       endgraf () ; 
  2175.       unsave () ; 
  2176.       alignpeek () ; 
  2177.     } 
  2178.     break ; 
  2179.   case 12 : 
  2180.     {
  2181.       endgraf () ; 
  2182.       unsave () ; 
  2183.       saveptr = saveptr - 2 ; 
  2184.       p = vpackage ( mem [(long) curlist .headfield ] .hh .v.RH , savestack [ 
  2185.       saveptr + 1 ] .cint , savestack [ saveptr + 0 ] .cint , 1073741823 ) ; 
  2186.       popnest () ; 
  2187.       {
  2188.     mem [(long) curlist .tailfield ] .hh .v.RH = newnoad () ; 
  2189.     curlist .tailfield = mem [(long) curlist .tailfield ] .hh .v.RH ; 
  2190.       } 
  2191.       mem [(long) curlist .tailfield ] .hh.b0 = 29 ; 
  2192.       mem [(long) curlist .tailfield + 1 ] .hh .v.RH = 2 ; 
  2193.       mem [(long) curlist .tailfield + 1 ] .hh .v.LH = p ; 
  2194.     } 
  2195.     break ; 
  2196.   case 13 : 
  2197.     buildchoices () ; 
  2198.     break ; 
  2199.   case 9 : 
  2200.     {
  2201.       unsave () ; 
  2202.       decr ( saveptr ) ; 
  2203.       mem [(long) savestack [ saveptr + 0 ] .cint ] .hh .v.RH = 3 ; 
  2204.       p = finmlist ( 0 ) ; 
  2205.       mem [(long) savestack [ saveptr + 0 ] .cint ] .hh .v.LH = p ; 
  2206.       if ( p != 0 ) 
  2207.       if ( mem [(long) p ] .hh .v.RH == 0 ) 
  2208.       if ( mem [(long) p ] .hh.b0 == 16 ) 
  2209.       {
  2210.     if ( mem [(long) p + 3 ] .hh .v.RH == 0 ) 
  2211.     if ( mem [(long) p + 2 ] .hh .v.RH == 0 ) 
  2212.     {
  2213.       mem [(long) savestack [ saveptr + 0 ] .cint ] .hh = mem [(long) p + 1 ] .hh ; 
  2214.       freenode ( p , 4 ) ; 
  2215.     } 
  2216.       } 
  2217.       else if ( mem [(long) p ] .hh.b0 == 28 ) 
  2218.       if ( savestack [ saveptr + 0 ] .cint == curlist .tailfield + 1 ) 
  2219.       if ( mem [(long) curlist .tailfield ] .hh.b0 == 16 ) 
  2220.       {
  2221.     q = curlist .headfield ; 
  2222.     while ( mem [(long) q ] .hh .v.RH != curlist .tailfield ) q = mem [(long) q ] .hh 
  2223.     .v.RH ; 
  2224.     mem [(long) q ] .hh .v.RH = p ; 
  2225.     freenode ( curlist .tailfield , 4 ) ; 
  2226.     curlist .tailfield = p ; 
  2227.       } 
  2228.     } 
  2229.     break ; 
  2230.   default : 
  2231.     confusion ( 895 ) ; 
  2232.     break ; 
  2233.   } 
  2234. } 
  2235.