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