home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex10.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  35.9 KB  |  1,333 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void pushalignment ( ) 
  5. {pushalignment_regmem 
  6.   halfword p  ; 
  7.   p = getnode ( 5 ) ; 
  8.   mem [ p ] .hh .v.RH = alignptr ; 
  9.   mem [ p ] .hh .v.LH = curalign ; 
  10.   mem [ p + 1 ] .hh .v.LH = mem [ memtop - 8 ] .hh .v.RH ; 
  11.   mem [ p + 1 ] .hh .v.RH = curspan ; 
  12.   mem [ p + 2 ] .cint = curloop ; 
  13.   mem [ p + 3 ] .cint = alignstate ; 
  14.   mem [ p + 4 ] .hh .v.LH = curhead ; 
  15.   mem [ p + 4 ] .hh .v.RH = curtail ; 
  16.   alignptr = p ; 
  17.   curhead = getavail () ; 
  18. } 
  19. void popalignment ( ) 
  20. {popalignment_regmem 
  21.   halfword p  ; 
  22.   {
  23.     mem [ curhead ] .hh .v.RH = avail ; 
  24.     avail = curhead ; 
  25.     ;
  26. #ifdef STAT
  27.     decr ( dynused ) ; 
  28. #endif /* STAT */
  29.   } 
  30.   p = alignptr ; 
  31.   curtail = mem [ p + 4 ] .hh .v.RH ; 
  32.   curhead = mem [ p + 4 ] .hh .v.LH ; 
  33.   alignstate = mem [ p + 3 ] .cint ; 
  34.   curloop = mem [ p + 2 ] .cint ; 
  35.   curspan = mem [ p + 1 ] .hh .v.RH ; 
  36.   mem [ memtop - 8 ] .hh .v.RH = mem [ p + 1 ] .hh .v.LH ; 
  37.   curalign = mem [ p ] .hh .v.LH ; 
  38.   alignptr = mem [ p ] .hh .v.RH ; 
  39.   freenode ( p , 5 ) ; 
  40. } 
  41. void getpreambletoken ( ) 
  42. {/* 20 */ getpreambletoken_regmem 
  43.   lab20: gettoken () ; 
  44.   while ( ( curchr == 256 ) && ( curcmd == 4 ) ) {
  45.       
  46.     gettoken () ; 
  47.     if ( curcmd > 100 ) 
  48.     {
  49.       expand () ; 
  50.       gettoken () ; 
  51.     } 
  52.   } 
  53.   if ( curcmd == 9 ) 
  54.   fatalerror ( 591 ) ; 
  55.   if ( ( curcmd == 75 ) && ( curchr == 3793 ) ) 
  56.   {
  57.     scanoptionalequals () ; 
  58.     scanglue ( 2 ) ; 
  59.     if ( eqtb [ 6206 ] .cint > 0 ) 
  60.     geqdefine ( 3793 , 117 , curval ) ; 
  61.     else eqdefine ( 3793 , 117 , curval ) ; 
  62.     goto lab20 ; 
  63.   } 
  64. } 
  65. void initalign ( ) 
  66. {/* 30 31 32 22 */ initalign_regmem 
  67.   halfword savecsptr  ; 
  68.   halfword p  ; 
  69.   savecsptr = curcs ; 
  70.   pushalignment () ; 
  71.   alignstate = -1000000L ; 
  72.   if ( ( curlist .modefield == 203 ) && ( ( curlist .tailfield != curlist 
  73.   .headfield ) || ( curlist .auxfield .cint != 0 ) ) ) 
  74.   {
  75.     {
  76.       if ( interaction == 3 ) 
  77.       wakeupterminal () ; 
  78.       printnl ( 262 ) ; 
  79.       print ( 676 ) ; 
  80.     } 
  81.     printesc ( 516 ) ; 
  82.     print ( 887 ) ; 
  83.     {
  84.       helpptr = 3 ; 
  85.       helpline [ 2 ] = 888 ; 
  86.       helpline [ 1 ] = 889 ; 
  87.       helpline [ 0 ] = 890 ; 
  88.     } 
  89.     error () ; 
  90.     flushmath () ; 
  91.   } 
  92.   pushnest () ; 
  93.   if ( curlist .modefield == 203 ) 
  94.   {
  95.     curlist .modefield = -1 ; 
  96.     curlist .auxfield .cint = nest [ nestptr - 2 ] .auxfield .cint ; 
  97.   } 
  98.   else if ( curlist .modefield > 0 ) 
  99.   curlist .modefield = - (integer) curlist .modefield ; 
  100.   scanspec ( 6 , false ) ; 
  101.   mem [ memtop - 8 ] .hh .v.RH = 0 ; 
  102.   curalign = memtop - 8 ; 
  103.   curloop = 0 ; 
  104.   scannerstatus = 4 ; 
  105.   warningindex = savecsptr ; 
  106.   alignstate = -1000000L ; 
  107.   while ( true ) {
  108.       
  109.     mem [ curalign ] .hh .v.RH = newparamglue ( 11 ) ; 
  110.     curalign = mem [ curalign ] .hh .v.RH ; 
  111.     if ( curcmd == 5 ) 
  112.     goto lab30 ; 
  113.     p = memtop - 4 ; 
  114.     mem [ p ] .hh .v.RH = 0 ; 
  115.     while ( true ) {
  116.     
  117.       getpreambletoken () ; 
  118.       if ( curcmd == 6 ) 
  119.       goto lab31 ; 
  120.       if ( ( curcmd <= 5 ) && ( curcmd >= 4 ) && ( alignstate == -1000000L ) ) 
  121.       if ( ( p == memtop - 4 ) && ( curloop == 0 ) && ( curcmd == 4 ) ) 
  122.       curloop = curalign ; 
  123.       else {
  124.       
  125.     {
  126.       if ( interaction == 3 ) 
  127.       wakeupterminal () ; 
  128.       printnl ( 262 ) ; 
  129.       print ( 896 ) ; 
  130.     } 
  131.     {
  132.       helpptr = 3 ; 
  133.       helpline [ 2 ] = 897 ; 
  134.       helpline [ 1 ] = 898 ; 
  135.       helpline [ 0 ] = 899 ; 
  136.     } 
  137.     backerror () ; 
  138.     goto lab31 ; 
  139.       } 
  140.       else if ( ( curcmd != 10 ) || ( p != memtop - 4 ) ) 
  141.       {
  142.     mem [ p ] .hh .v.RH = getavail () ; 
  143.     p = mem [ p ] .hh .v.RH ; 
  144.     mem [ p ] .hh .v.LH = curtok ; 
  145.       } 
  146.     } 
  147.     lab31: ; 
  148.     mem [ curalign ] .hh .v.RH = newnullbox () ; 
  149.     curalign = mem [ curalign ] .hh .v.RH ; 
  150.     mem [ curalign ] .hh .v.LH = memtop - 9 ; 
  151.     mem [ curalign + 1 ] .cint = -1073741824L ; 
  152.     mem [ curalign + 3 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  153.     p = memtop - 4 ; 
  154.     mem [ p ] .hh .v.RH = 0 ; 
  155.     while ( true ) {
  156.     
  157.       lab22: getpreambletoken () ; 
  158.       if ( ( curcmd <= 5 ) && ( curcmd >= 4 ) && ( alignstate == -1000000L ) ) 
  159.       goto lab32 ; 
  160.       if ( curcmd == 6 ) 
  161.       {
  162.     {
  163.       if ( interaction == 3 ) 
  164.       wakeupterminal () ; 
  165.       printnl ( 262 ) ; 
  166.       print ( 900 ) ; 
  167.     } 
  168.     {
  169.       helpptr = 3 ; 
  170.       helpline [ 2 ] = 897 ; 
  171.       helpline [ 1 ] = 898 ; 
  172.       helpline [ 0 ] = 901 ; 
  173.     } 
  174.     error () ; 
  175.     goto lab22 ; 
  176.       } 
  177.       mem [ p ] .hh .v.RH = getavail () ; 
  178.       p = mem [ p ] .hh .v.RH ; 
  179.       mem [ p ] .hh .v.LH = curtok ; 
  180.     } 
  181.     lab32: mem [ p ] .hh .v.RH = getavail () ; 
  182.     p = mem [ p ] .hh .v.RH ; 
  183.     mem [ p ] .hh .v.LH = 7614 ; 
  184.     mem [ curalign + 2 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  185.   } 
  186.   lab30: scannerstatus = 0 ; 
  187.   newsavelevel ( 6 ) ; 
  188.   if ( eqtb [ 4320 ] .hh .v.RH != 0 ) 
  189.   begintokenlist ( eqtb [ 4320 ] .hh .v.RH , 13 ) ; 
  190.   alignpeek () ; 
  191. } 
  192. void zinitspan ( p ) 
  193. halfword p ; 
  194. {initspan_regmem 
  195.   pushnest () ; 
  196.   if ( curlist .modefield == -102 ) 
  197.   curlist .auxfield .hh .v.LH = 1000 ; 
  198.   else {
  199.       
  200.     curlist .auxfield .cint = -65536000L ; 
  201.     normalparagraph () ; 
  202.   } 
  203.   curspan = p ; 
  204. } 
  205. void initrow ( ) 
  206. {initrow_regmem 
  207.   pushnest () ; 
  208.   curlist .modefield = ( -103 ) - curlist .modefield ; 
  209.   if ( curlist .modefield == -102 ) 
  210.   curlist .auxfield .hh .v.LH = 0 ; 
  211.   else curlist .auxfield .cint = 0 ; 
  212.   {
  213.     mem [ curlist .tailfield ] .hh .v.RH = newglue ( mem [ mem [ memtop - 8 ] 
  214.     .hh .v.RH + 1 ] .hh .v.LH ) ; 
  215.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  216.   } 
  217.   mem [ curlist .tailfield ] .hh.b1 = 12 ; 
  218.   curalign = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  219.   curtail = curhead ; 
  220.   initspan ( curalign ) ; 
  221. } 
  222. void initcol ( ) 
  223. {initcol_regmem 
  224.   mem [ curalign + 5 ] .hh .v.LH = curcmd ; 
  225.   if ( curcmd == 63 ) 
  226.   alignstate = 0 ; 
  227.   else {
  228.       
  229.     backinput () ; 
  230.     begintokenlist ( mem [ curalign + 3 ] .cint , 1 ) ; 
  231.   } 
  232. } 
  233. boolean fincol ( ) 
  234. {/* 10 */ register boolean Result; fincol_regmem 
  235.   halfword p  ; 
  236.   halfword q, r  ; 
  237.   halfword s  ; 
  238.   halfword u  ; 
  239.   scaled w  ; 
  240.   glueord o  ; 
  241.   halfword n  ; 
  242.   if ( curalign == 0 ) 
  243.   confusion ( 902 ) ; 
  244.   q = mem [ curalign ] .hh .v.RH ; 
  245.   if ( q == 0 ) 
  246.   confusion ( 902 ) ; 
  247.   if ( alignstate < 500000L ) 
  248.   fatalerror ( 591 ) ; 
  249.   p = mem [ q ] .hh .v.RH ; 
  250.   if ( ( p == 0 ) && ( mem [ curalign + 5 ] .hh .v.LH < 257 ) ) 
  251.   if ( curloop != 0 ) 
  252.   {
  253.     mem [ q ] .hh .v.RH = newnullbox () ; 
  254.     p = mem [ q ] .hh .v.RH ; 
  255.     mem [ p ] .hh .v.LH = memtop - 9 ; 
  256.     mem [ p + 1 ] .cint = -1073741824L ; 
  257.     curloop = mem [ curloop ] .hh .v.RH ; 
  258.     q = memtop - 4 ; 
  259.     r = mem [ curloop + 3 ] .cint ; 
  260.     while ( r != 0 ) {
  261.     
  262.       mem [ q ] .hh .v.RH = getavail () ; 
  263.       q = mem [ q ] .hh .v.RH ; 
  264.       mem [ q ] .hh .v.LH = mem [ r ] .hh .v.LH ; 
  265.       r = mem [ r ] .hh .v.RH ; 
  266.     } 
  267.     mem [ q ] .hh .v.RH = 0 ; 
  268.     mem [ p + 3 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  269.     q = memtop - 4 ; 
  270.     r = mem [ curloop + 2 ] .cint ; 
  271.     while ( r != 0 ) {
  272.     
  273.       mem [ q ] .hh .v.RH = getavail () ; 
  274.       q = mem [ q ] .hh .v.RH ; 
  275.       mem [ q ] .hh .v.LH = mem [ r ] .hh .v.LH ; 
  276.       r = mem [ r ] .hh .v.RH ; 
  277.     } 
  278.     mem [ q ] .hh .v.RH = 0 ; 
  279.     mem [ p + 2 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  280.     curloop = mem [ curloop ] .hh .v.RH ; 
  281.     mem [ p ] .hh .v.RH = newglue ( mem [ curloop + 1 ] .hh .v.LH ) ; 
  282.   } 
  283.   else {
  284.       
  285.     {
  286.       if ( interaction == 3 ) 
  287.       wakeupterminal () ; 
  288.       printnl ( 262 ) ; 
  289.       print ( 903 ) ; 
  290.     } 
  291.     printesc ( 892 ) ; 
  292.     {
  293.       helpptr = 3 ; 
  294.       helpline [ 2 ] = 904 ; 
  295.       helpline [ 1 ] = 905 ; 
  296.       helpline [ 0 ] = 906 ; 
  297.     } 
  298.     mem [ curalign + 5 ] .hh .v.LH = 257 ; 
  299.     error () ; 
  300.   } 
  301.   if ( mem [ curalign + 5 ] .hh .v.LH != 256 ) 
  302.   {
  303.     unsave () ; 
  304.     newsavelevel ( 6 ) ; 
  305.     {
  306.       if ( curlist .modefield == -102 ) 
  307.       {
  308.     adjusttail = curtail ; 
  309.     u = hpack ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 ) ; 
  310.     w = mem [ u + 1 ] .cint ; 
  311.     curtail = adjusttail ; 
  312.     adjusttail = 0 ; 
  313.       } 
  314.       else {
  315.       
  316.     u = vpackage ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 , 0 ) ; 
  317.     w = mem [ u + 3 ] .cint ; 
  318.       } 
  319.       n = 0 ; 
  320.       if ( curspan != curalign ) 
  321.       {
  322.     q = curspan ; 
  323.     do {
  324.         incr ( n ) ; 
  325.       q = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  326.     } while ( ! ( q == curalign ) ) ; 
  327.     if ( n > 255 ) 
  328.     confusion ( 907 ) ; 
  329.     q = curspan ; 
  330.     while ( mem [ mem [ q ] .hh .v.LH ] .hh .v.RH < n ) q = mem [ q ] .hh 
  331.     .v.LH ; 
  332.     if ( mem [ mem [ q ] .hh .v.LH ] .hh .v.RH > n ) 
  333.     {
  334.       s = getnode ( 2 ) ; 
  335.       mem [ s ] .hh .v.LH = mem [ q ] .hh .v.LH ; 
  336.       mem [ s ] .hh .v.RH = n ; 
  337.       mem [ q ] .hh .v.LH = s ; 
  338.       mem [ s + 1 ] .cint = w ; 
  339.     } 
  340.     else if ( mem [ mem [ q ] .hh .v.LH + 1 ] .cint < w ) 
  341.     mem [ mem [ q ] .hh .v.LH + 1 ] .cint = w ; 
  342.       } 
  343.       else if ( w > mem [ curalign + 1 ] .cint ) 
  344.       mem [ curalign + 1 ] .cint = w ; 
  345.       mem [ u ] .hh.b0 = 13 ; 
  346.       mem [ u ] .hh.b1 = n ; 
  347.       if ( totalstretch [ 3 ] != 0 ) 
  348.       o = 3 ; 
  349.       else if ( totalstretch [ 2 ] != 0 ) 
  350.       o = 2 ; 
  351.       else if ( totalstretch [ 1 ] != 0 ) 
  352.       o = 1 ; 
  353.       else o = 0 ; 
  354.       mem [ u + 5 ] .hh.b1 = o ; 
  355.       mem [ u + 6 ] .cint = totalstretch [ o ] ; 
  356.       if ( totalshrink [ 3 ] != 0 ) 
  357.       o = 3 ; 
  358.       else if ( totalshrink [ 2 ] != 0 ) 
  359.       o = 2 ; 
  360.       else if ( totalshrink [ 1 ] != 0 ) 
  361.       o = 1 ; 
  362.       else o = 0 ; 
  363.       mem [ u + 5 ] .hh.b0 = o ; 
  364.       mem [ u + 4 ] .cint = totalshrink [ o ] ; 
  365.       popnest () ; 
  366.       mem [ curlist .tailfield ] .hh .v.RH = u ; 
  367.       curlist .tailfield = u ; 
  368.     } 
  369.     {
  370.       mem [ curlist .tailfield ] .hh .v.RH = newglue ( mem [ mem [ curalign ] 
  371.       .hh .v.RH + 1 ] .hh .v.LH ) ; 
  372.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  373.     } 
  374.     mem [ curlist .tailfield ] .hh.b1 = 12 ; 
  375.     if ( mem [ curalign + 5 ] .hh .v.LH >= 257 ) 
  376.     {
  377.       Result = true ; 
  378.       return(Result) ; 
  379.     } 
  380.     initspan ( p ) ; 
  381.   } 
  382.   alignstate = 1000000L ; 
  383.   do {
  384.       getxtoken () ; 
  385.   } while ( ! ( curcmd != 10 ) ) ; 
  386.   curalign = p ; 
  387.   initcol () ; 
  388.   Result = false ; 
  389.   return(Result) ; 
  390. } 
  391. void finrow ( ) 
  392. {finrow_regmem 
  393.   halfword p  ; 
  394.   if ( curlist .modefield == -102 ) 
  395.   {
  396.     p = hpack ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 ) ; 
  397.     popnest () ; 
  398.     appendtovlist ( p ) ; 
  399.     if ( curhead != curtail ) 
  400.     {
  401.       mem [ curlist .tailfield ] .hh .v.RH = mem [ curhead ] .hh .v.RH ; 
  402.       curlist .tailfield = curtail ; 
  403.     } 
  404.   } 
  405.   else {
  406.       
  407.     p = vpackage ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 , 1073741823L 
  408.     ) ; 
  409.     popnest () ; 
  410.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  411.     curlist .tailfield = p ; 
  412.     curlist .auxfield .hh .v.LH = 1000 ; 
  413.   } 
  414.   mem [ p ] .hh.b0 = 13 ; 
  415.   mem [ p + 6 ] .cint = 0 ; 
  416.   if ( eqtb [ 4320 ] .hh .v.RH != 0 ) 
  417.   begintokenlist ( eqtb [ 4320 ] .hh .v.RH , 13 ) ; 
  418.   alignpeek () ; 
  419. } 
  420. void finalign ( ) 
  421. {finalign_regmem 
  422.   halfword p, q, r, s, u, v  ; 
  423.   scaled t, w  ; 
  424.   scaled o  ; 
  425.   halfword n  ; 
  426.   scaled rulesave  ; 
  427.   memoryword auxsave  ; 
  428.   if ( curgroup != 6 ) 
  429.   confusion ( 908 ) ; 
  430.   unsave () ; 
  431.   if ( curgroup != 6 ) 
  432.   confusion ( 909 ) ; 
  433.   unsave () ; 
  434.   if ( nest [ nestptr - 1 ] .modefield == 203 ) 
  435.   o = eqtb [ 6745 ] .cint ; 
  436.   else o = 0 ; 
  437.   q = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  438.   do {
  439.       flushlist ( mem [ q + 3 ] .cint ) ; 
  440.     flushlist ( mem [ q + 2 ] .cint ) ; 
  441.     p = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  442.     if ( mem [ q + 1 ] .cint == -1073741824L ) 
  443.     {
  444.       mem [ q + 1 ] .cint = 0 ; 
  445.       r = mem [ q ] .hh .v.RH ; 
  446.       s = mem [ r + 1 ] .hh .v.LH ; 
  447.       if ( s != 0 ) 
  448.       {
  449.     incr ( mem [ 0 ] .hh .v.RH ) ; 
  450.     deleteglueref ( s ) ; 
  451.     mem [ r + 1 ] .hh .v.LH = 0 ; 
  452.       } 
  453.     } 
  454.     if ( mem [ q ] .hh .v.LH != memtop - 9 ) 
  455.     {
  456.       t = mem [ q + 1 ] .cint + mem [ mem [ mem [ q ] .hh .v.RH + 1 ] .hh 
  457.       .v.LH + 1 ] .cint ; 
  458.       r = mem [ q ] .hh .v.LH ; 
  459.       s = memtop - 9 ; 
  460.       mem [ s ] .hh .v.LH = p ; 
  461.       n = 1 ; 
  462.       do {
  463.       mem [ r + 1 ] .cint = mem [ r + 1 ] .cint - t ; 
  464.     u = mem [ r ] .hh .v.LH ; 
  465.     while ( mem [ r ] .hh .v.RH > n ) {
  466.         
  467.       s = mem [ s ] .hh .v.LH ; 
  468.       n = mem [ mem [ s ] .hh .v.LH ] .hh .v.RH + 1 ; 
  469.     } 
  470.     if ( mem [ r ] .hh .v.RH < n ) 
  471.     {
  472.       mem [ r ] .hh .v.LH = mem [ s ] .hh .v.LH ; 
  473.       mem [ s ] .hh .v.LH = r ; 
  474.       decr ( mem [ r ] .hh .v.RH ) ; 
  475.       s = r ; 
  476.     } 
  477.     else {
  478.         
  479.       if ( mem [ r + 1 ] .cint > mem [ mem [ s ] .hh .v.LH + 1 ] .cint ) 
  480.       mem [ mem [ s ] .hh .v.LH + 1 ] .cint = mem [ r + 1 ] .cint ; 
  481.       freenode ( r , 2 ) ; 
  482.     } 
  483.     r = u ; 
  484.       } while ( ! ( r == memtop - 9 ) ) ; 
  485.     } 
  486.     mem [ q ] .hh.b0 = 13 ; 
  487.     mem [ q ] .hh.b1 = 0 ; 
  488.     mem [ q + 3 ] .cint = 0 ; 
  489.     mem [ q + 2 ] .cint = 0 ; 
  490.     mem [ q + 5 ] .hh.b1 = 0 ; 
  491.     mem [ q + 5 ] .hh.b0 = 0 ; 
  492.     mem [ q + 6 ] .cint = 0 ; 
  493.     mem [ q + 4 ] .cint = 0 ; 
  494.     q = p ; 
  495.   } while ( ! ( q == 0 ) ) ; 
  496.   saveptr = saveptr - 2 ; 
  497.   packbeginline = - (integer) curlist .mlfield ; 
  498.   if ( curlist .modefield == -1 ) 
  499.   {
  500.     rulesave = eqtb [ 6746 ] .cint ; 
  501.     eqtb [ 6746 ] .cint = 0 ; 
  502.     p = hpack ( mem [ memtop - 8 ] .hh .v.RH , savestack [ saveptr + 1 ] .cint 
  503.     , savestack [ saveptr + 0 ] .cint ) ; 
  504.     eqtb [ 6746 ] .cint = rulesave ; 
  505.   } 
  506.   else {
  507.       
  508.     q = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  509.     do {
  510.     mem [ q + 3 ] .cint = mem [ q + 1 ] .cint ; 
  511.       mem [ q + 1 ] .cint = 0 ; 
  512.       q = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  513.     } while ( ! ( q == 0 ) ) ; 
  514.     p = vpackage ( mem [ memtop - 8 ] .hh .v.RH , savestack [ saveptr + 1 ] 
  515.     .cint , savestack [ saveptr + 0 ] .cint , 1073741823L ) ; 
  516.     q = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  517.     do {
  518.     mem [ q + 1 ] .cint = mem [ q + 3 ] .cint ; 
  519.       mem [ q + 3 ] .cint = 0 ; 
  520.       q = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  521.     } while ( ! ( q == 0 ) ) ; 
  522.   } 
  523.   packbeginline = 0 ; 
  524.   q = mem [ curlist .headfield ] .hh .v.RH ; 
  525.   s = curlist .headfield ; 
  526.   while ( q != 0 ) {
  527.       
  528.     if ( ! ( q >= himemmin ) ) 
  529.     if ( mem [ q ] .hh.b0 == 13 ) 
  530.     {
  531.       if ( curlist .modefield == -1 ) 
  532.       {
  533.     mem [ q ] .hh.b0 = 0 ; 
  534.     mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  535.       } 
  536.       else {
  537.       
  538.     mem [ q ] .hh.b0 = 1 ; 
  539.     mem [ q + 3 ] .cint = mem [ p + 3 ] .cint ; 
  540.       } 
  541.       mem [ q + 5 ] .hh.b1 = mem [ p + 5 ] .hh.b1 ; 
  542.       mem [ q + 5 ] .hh.b0 = mem [ p + 5 ] .hh.b0 ; 
  543.       mem [ q + 6 ] .gr = mem [ p + 6 ] .gr ; 
  544.       mem [ q + 4 ] .cint = o ; 
  545.       r = mem [ mem [ q + 5 ] .hh .v.RH ] .hh .v.RH ; 
  546.       s = mem [ mem [ p + 5 ] .hh .v.RH ] .hh .v.RH ; 
  547.       do {
  548.       n = mem [ r ] .hh.b1 ; 
  549.     t = mem [ s + 1 ] .cint ; 
  550.     w = t ; 
  551.     u = memtop - 4 ; 
  552.     while ( n > 0 ) {
  553.         
  554.       decr ( n ) ; 
  555.       s = mem [ s ] .hh .v.RH ; 
  556.       v = mem [ s + 1 ] .hh .v.LH ; 
  557.       mem [ u ] .hh .v.RH = newglue ( v ) ; 
  558.       u = mem [ u ] .hh .v.RH ; 
  559.       mem [ u ] .hh.b1 = 12 ; 
  560.       t = t + mem [ v + 1 ] .cint ; 
  561.       if ( mem [ p + 5 ] .hh.b0 == 1 ) 
  562.       {
  563.         if ( mem [ v ] .hh.b0 == mem [ p + 5 ] .hh.b1 ) 
  564.         t = t + round ( mem [ p + 6 ] .gr * mem [ v + 2 ] .cint ) ; 
  565.       } 
  566.       else if ( mem [ p + 5 ] .hh.b0 == 2 ) 
  567.       {
  568.         if ( mem [ v ] .hh.b1 == mem [ p + 5 ] .hh.b1 ) 
  569.         t = t - round ( mem [ p + 6 ] .gr * mem [ v + 3 ] .cint ) ; 
  570.       } 
  571.       s = mem [ s ] .hh .v.RH ; 
  572.       mem [ u ] .hh .v.RH = newnullbox () ; 
  573.       u = mem [ u ] .hh .v.RH ; 
  574.       t = t + mem [ s + 1 ] .cint ; 
  575.       if ( curlist .modefield == -1 ) 
  576.       mem [ u + 1 ] .cint = mem [ s + 1 ] .cint ; 
  577.       else {
  578.           
  579.         mem [ u ] .hh.b0 = 1 ; 
  580.         mem [ u + 3 ] .cint = mem [ s + 1 ] .cint ; 
  581.       } 
  582.     } 
  583.     if ( curlist .modefield == -1 ) 
  584.     {
  585.       mem [ r + 3 ] .cint = mem [ q + 3 ] .cint ; 
  586.       mem [ r + 2 ] .cint = mem [ q + 2 ] .cint ; 
  587.       if ( t == mem [ r + 1 ] .cint ) 
  588.       {
  589.         mem [ r + 5 ] .hh.b0 = 0 ; 
  590.         mem [ r + 5 ] .hh.b1 = 0 ; 
  591.         mem [ r + 6 ] .gr = 0.0 ; 
  592.       } 
  593.       else if ( t > mem [ r + 1 ] .cint ) 
  594.       {
  595.         mem [ r + 5 ] .hh.b0 = 1 ; 
  596.         if ( mem [ r + 6 ] .cint == 0 ) 
  597.         mem [ r + 6 ] .gr = 0.0 ; 
  598.         else mem [ r + 6 ] .gr = ( t - mem [ r + 1 ] .cint ) / ((double) 
  599.         mem [ r + 6 ] .cint ) ; 
  600.       } 
  601.       else {
  602.           
  603.         mem [ r + 5 ] .hh.b1 = mem [ r + 5 ] .hh.b0 ; 
  604.         mem [ r + 5 ] .hh.b0 = 2 ; 
  605.         if ( mem [ r + 4 ] .cint == 0 ) 
  606.         mem [ r + 6 ] .gr = 0.0 ; 
  607.         else if ( ( mem [ r + 5 ] .hh.b1 == 0 ) && ( mem [ r + 1 ] .cint - 
  608.         t > mem [ r + 4 ] .cint ) ) 
  609.         mem [ r + 6 ] .gr = 1.0 ; 
  610.         else mem [ r + 6 ] .gr = ( mem [ r + 1 ] .cint - t ) / ((double) 
  611.         mem [ r + 4 ] .cint ) ; 
  612.       } 
  613.       mem [ r + 1 ] .cint = w ; 
  614.       mem [ r ] .hh.b0 = 0 ; 
  615.     } 
  616.     else {
  617.         
  618.       mem [ r + 1 ] .cint = mem [ q + 1 ] .cint ; 
  619.       if ( t == mem [ r + 3 ] .cint ) 
  620.       {
  621.         mem [ r + 5 ] .hh.b0 = 0 ; 
  622.         mem [ r + 5 ] .hh.b1 = 0 ; 
  623.         mem [ r + 6 ] .gr = 0.0 ; 
  624.       } 
  625.       else if ( t > mem [ r + 3 ] .cint ) 
  626.       {
  627.         mem [ r + 5 ] .hh.b0 = 1 ; 
  628.         if ( mem [ r + 6 ] .cint == 0 ) 
  629.         mem [ r + 6 ] .gr = 0.0 ; 
  630.         else mem [ r + 6 ] .gr = ( t - mem [ r + 3 ] .cint ) / ((double) 
  631.         mem [ r + 6 ] .cint ) ; 
  632.       } 
  633.       else {
  634.           
  635.         mem [ r + 5 ] .hh.b1 = mem [ r + 5 ] .hh.b0 ; 
  636.         mem [ r + 5 ] .hh.b0 = 2 ; 
  637.         if ( mem [ r + 4 ] .cint == 0 ) 
  638.         mem [ r + 6 ] .gr = 0.0 ; 
  639.         else if ( ( mem [ r + 5 ] .hh.b1 == 0 ) && ( mem [ r + 3 ] .cint - 
  640.         t > mem [ r + 4 ] .cint ) ) 
  641.         mem [ r + 6 ] .gr = 1.0 ; 
  642.         else mem [ r + 6 ] .gr = ( mem [ r + 3 ] .cint - t ) / ((double) 
  643.         mem [ r + 4 ] .cint ) ; 
  644.       } 
  645.       mem [ r + 3 ] .cint = w ; 
  646.       mem [ r ] .hh.b0 = 1 ; 
  647.     } 
  648.     mem [ r + 4 ] .cint = 0 ; 
  649.     if ( u != memtop - 4 ) 
  650.     {
  651.       mem [ u ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  652.       mem [ r ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  653.       r = u ; 
  654.     } 
  655.     r = mem [ mem [ r ] .hh .v.RH ] .hh .v.RH ; 
  656.     s = mem [ mem [ s ] .hh .v.RH ] .hh .v.RH ; 
  657.       } while ( ! ( r == 0 ) ) ; 
  658.     } 
  659.     else if ( mem [ q ] .hh.b0 == 2 ) 
  660.     {
  661.       if ( ( mem [ q + 1 ] .cint == -1073741824L ) ) 
  662.       mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  663.       if ( ( mem [ q + 3 ] .cint == -1073741824L ) ) 
  664.       mem [ q + 3 ] .cint = mem [ p + 3 ] .cint ; 
  665.       if ( ( mem [ q + 2 ] .cint == -1073741824L ) ) 
  666.       mem [ q + 2 ] .cint = mem [ p + 2 ] .cint ; 
  667.       if ( o != 0 ) 
  668.       {
  669.     r = mem [ q ] .hh .v.RH ; 
  670.     mem [ q ] .hh .v.RH = 0 ; 
  671.     q = hpack ( q , 0 , 1 ) ; 
  672.     mem [ q + 4 ] .cint = o ; 
  673.     mem [ q ] .hh .v.RH = r ; 
  674.     mem [ s ] .hh .v.RH = q ; 
  675.       } 
  676.     } 
  677.     s = q ; 
  678.     q = mem [ q ] .hh .v.RH ; 
  679.   } 
  680.   flushnodelist ( p ) ; 
  681.   popalignment () ; 
  682.   auxsave = curlist .auxfield ; 
  683.   p = mem [ curlist .headfield ] .hh .v.RH ; 
  684.   q = curlist .tailfield ; 
  685.   popnest () ; 
  686.   if ( curlist .modefield == 203 ) 
  687.   {
  688.     doassignments () ; 
  689.     if ( curcmd != 3 ) 
  690.     {
  691.       {
  692.     if ( interaction == 3 ) 
  693.     wakeupterminal () ; 
  694.     printnl ( 262 ) ; 
  695.     print ( 1163 ) ; 
  696.       } 
  697.       {
  698.     helpptr = 2 ; 
  699.     helpline [ 1 ] = 888 ; 
  700.     helpline [ 0 ] = 889 ; 
  701.       } 
  702.       backerror () ; 
  703.     } 
  704.     else {
  705.     
  706.       getxtoken () ; 
  707.       if ( curcmd != 3 ) 
  708.       {
  709.     {
  710.       if ( interaction == 3 ) 
  711.       wakeupterminal () ; 
  712.       printnl ( 262 ) ; 
  713.       print ( 1159 ) ; 
  714.     } 
  715.     {
  716.       helpptr = 2 ; 
  717.       helpline [ 1 ] = 1160 ; 
  718.       helpline [ 0 ] = 1161 ; 
  719.     } 
  720.     backerror () ; 
  721.       } 
  722.     } 
  723.     popnest () ; 
  724.     {
  725.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 6174 ] .cint 
  726.       ) ; 
  727.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  728.     } 
  729.     {
  730.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( 3 ) ; 
  731.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  732.     } 
  733.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  734.     if ( p != 0 ) 
  735.     curlist .tailfield = q ; 
  736.     {
  737.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 6175 ] .cint 
  738.       ) ; 
  739.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  740.     } 
  741.     {
  742.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( 4 ) ; 
  743.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  744.     } 
  745.     curlist .auxfield .cint = auxsave .cint ; 
  746.     resumeafterdisplay () ; 
  747.   } 
  748.   else {
  749.       
  750.     curlist .auxfield = auxsave ; 
  751.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  752.     if ( p != 0 ) 
  753.     curlist .tailfield = q ; 
  754.     if ( curlist .modefield == 1 ) 
  755.     buildpage () ; 
  756.   } 
  757. } 
  758. void alignpeek ( ) 
  759. {/* 20 */ alignpeek_regmem 
  760.   lab20: alignstate = 1000000L ; 
  761.   do {
  762.       getxtoken () ; 
  763.   } while ( ! ( curcmd != 10 ) ) ; 
  764.   if ( curcmd == 34 ) 
  765.   {
  766.     scanleftbrace () ; 
  767.     newsavelevel ( 7 ) ; 
  768.     if ( curlist .modefield == -1 ) 
  769.     normalparagraph () ; 
  770.   } 
  771.   else if ( curcmd == 2 ) 
  772.   finalign () ; 
  773.   else if ( ( curcmd == 5 ) && ( curchr == 258 ) ) 
  774.   goto lab20 ; 
  775.   else {
  776.       
  777.     initrow () ; 
  778.     initcol () ; 
  779.   } 
  780. } 
  781. halfword zfiniteshrink ( p ) 
  782. halfword p ; 
  783. {register halfword Result; finiteshrink_regmem 
  784.   halfword q  ; 
  785.   if ( noshrinkerroryet ) 
  786.   {
  787.     noshrinkerroryet = false ; 
  788.     {
  789.       if ( interaction == 3 ) 
  790.       wakeupterminal () ; 
  791.       printnl ( 262 ) ; 
  792.       print ( 910 ) ; 
  793.     } 
  794.     {
  795.       helpptr = 5 ; 
  796.       helpline [ 4 ] = 911 ; 
  797.       helpline [ 3 ] = 912 ; 
  798.       helpline [ 2 ] = 913 ; 
  799.       helpline [ 1 ] = 914 ; 
  800.       helpline [ 0 ] = 915 ; 
  801.     } 
  802.     error () ; 
  803.   } 
  804.   q = newspec ( p ) ; 
  805.   mem [ q ] .hh.b1 = 0 ; 
  806.   deleteglueref ( p ) ; 
  807.   Result = q ; 
  808.   return(Result) ; 
  809. } 
  810. void ztrybreak ( pi , breaktype ) 
  811. integer pi ; 
  812. smallnumber breaktype ; 
  813. {/* 10 30 31 22 60 */ trybreak_regmem 
  814.   halfword r  ; 
  815.   halfword prevr  ; 
  816.   halfword oldl  ; 
  817.   boolean nobreakyet  ; 
  818.   halfword prevprevr  ; 
  819.   halfword s  ; 
  820.   halfword q  ; 
  821.   halfword v  ; 
  822.   integer t  ; 
  823.   internalfontnumber f  ; 
  824.   halfword l  ; 
  825.   boolean noderstaysactive  ; 
  826.   scaled linewidth  ; 
  827.   schar fitclass  ; 
  828.   halfword b  ; 
  829.   integer d  ; 
  830.   boolean artificialdemerits  ; 
  831.   halfword savelink  ; 
  832.   scaled shortfall  ; 
  833.   if ( abs ( pi ) >= 10000 ) 
  834.   if ( pi > 0 ) 
  835.   goto lab10 ; 
  836.   else pi = -10000 ; 
  837.   nobreakyet = true ; 
  838.   prevr = memtop - 7 ; 
  839.   oldl = 0 ; 
  840.   curactivewidth [ 1 ] = activewidth [ 1 ] ; 
  841.   curactivewidth [ 2 ] = activewidth [ 2 ] ; 
  842.   curactivewidth [ 3 ] = activewidth [ 3 ] ; 
  843.   curactivewidth [ 4 ] = activewidth [ 4 ] ; 
  844.   curactivewidth [ 5 ] = activewidth [ 5 ] ; 
  845.   curactivewidth [ 6 ] = activewidth [ 6 ] ; 
  846.   while ( true ) {
  847.       
  848.     lab22: r = mem [ prevr ] .hh .v.RH ; 
  849.     if ( mem [ r ] .hh.b0 == 2 ) 
  850.     {
  851.       curactivewidth [ 1 ] = curactivewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  852.       curactivewidth [ 2 ] = curactivewidth [ 2 ] + mem [ r + 2 ] .cint ; 
  853.       curactivewidth [ 3 ] = curactivewidth [ 3 ] + mem [ r + 3 ] .cint ; 
  854.       curactivewidth [ 4 ] = curactivewidth [ 4 ] + mem [ r + 4 ] .cint ; 
  855.       curactivewidth [ 5 ] = curactivewidth [ 5 ] + mem [ r + 5 ] .cint ; 
  856.       curactivewidth [ 6 ] = curactivewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  857.       prevprevr = prevr ; 
  858.       prevr = r ; 
  859.       goto lab22 ; 
  860.     } 
  861.     {
  862.       l = mem [ r + 1 ] .hh .v.LH ; 
  863.       if ( l > oldl ) 
  864.       {
  865.     if ( ( minimumdemerits < 1073741823L ) && ( ( oldl != easyline ) || ( 
  866.     r == memtop - 7 ) ) ) 
  867.     {
  868.       if ( nobreakyet ) 
  869.       {
  870.         nobreakyet = false ; 
  871.         breakwidth [ 1 ] = background [ 1 ] ; 
  872.         breakwidth [ 2 ] = background [ 2 ] ; 
  873.         breakwidth [ 3 ] = background [ 3 ] ; 
  874.         breakwidth [ 4 ] = background [ 4 ] ; 
  875.         breakwidth [ 5 ] = background [ 5 ] ; 
  876.         breakwidth [ 6 ] = background [ 6 ] ; 
  877.         s = curp ; 
  878.         if ( breaktype > 0 ) 
  879.         if ( curp != 0 ) 
  880.         {
  881.           t = mem [ curp ] .hh.b1 ; 
  882.           v = curp ; 
  883.           s = mem [ curp + 1 ] .hh .v.RH ; 
  884.           while ( t > 0 ) {
  885.           
  886.         decr ( t ) ; 
  887.         v = mem [ v ] .hh .v.RH ; 
  888.         if ( ( v >= himemmin ) ) 
  889.         {
  890.           f = mem [ v ] .hh.b0 ; 
  891.           breakwidth [ 1 ] = breakwidth [ 1 ] - fontinfo [ widthbase [ 
  892.           f ] + fontinfo [ charbase [ f ] + mem [ v ] .hh.b1 ] .qqqq 
  893.           .b0 ] .cint ; 
  894.         } 
  895.         else switch ( mem [ v ] .hh.b0 ) 
  896.         {case 6 : 
  897.           {
  898.             f = mem [ v + 1 ] .hh.b0 ; 
  899.             breakwidth [ 1 ] = breakwidth [ 1 ] - fontinfo [ widthbase 
  900.             [ f ] + fontinfo [ charbase [ f ] + mem [ v + 1 ] .hh.b1 ] 
  901.             .qqqq .b0 ] .cint ; 
  902.           } 
  903.           break ; 
  904.         case 0 : 
  905.         case 1 : 
  906.         case 2 : 
  907.         case 11 : 
  908.           breakwidth [ 1 ] = breakwidth [ 1 ] - mem [ v + 1 ] .cint ; 
  909.           break ; 
  910.           default: 
  911.           confusion ( 916 ) ; 
  912.           break ; 
  913.         } 
  914.           } 
  915.           while ( s != 0 ) {
  916.           
  917.         if ( ( s >= himemmin ) ) 
  918.         {
  919.           f = mem [ s ] .hh.b0 ; 
  920.           breakwidth [ 1 ] = breakwidth [ 1 ] + fontinfo [ widthbase [ 
  921.           f ] + fontinfo [ charbase [ f ] + mem [ s ] .hh.b1 ] .qqqq 
  922.           .b0 ] .cint ; 
  923.         } 
  924.         else switch ( mem [ s ] .hh.b0 ) 
  925.         {case 6 : 
  926.           {
  927.             f = mem [ s + 1 ] .hh.b0 ; 
  928.             breakwidth [ 1 ] = breakwidth [ 1 ] + fontinfo [ widthbase 
  929.             [ f ] + fontinfo [ charbase [ f ] + mem [ s + 1 ] .hh.b1 ] 
  930.             .qqqq .b0 ] .cint ; 
  931.           } 
  932.           break ; 
  933.         case 0 : 
  934.         case 1 : 
  935.         case 2 : 
  936.           breakwidth [ 1 ] = breakwidth [ 1 ] + mem [ s + 1 ] .cint ; 
  937.           break ; 
  938.         case 11 : 
  939.           if ( ( t == 0 ) && ( mem [ s ] .hh.b1 != 2 ) ) 
  940.           t = -1 ; 
  941.           else breakwidth [ 1 ] = breakwidth [ 1 ] + mem [ s + 1 ] 
  942.           .cint ; 
  943.           break ; 
  944.           default: 
  945.           confusion ( 917 ) ; 
  946.           break ; 
  947.         } 
  948.         incr ( t ) ; 
  949.         s = mem [ s ] .hh .v.RH ; 
  950.           } 
  951.           breakwidth [ 1 ] = breakwidth [ 1 ] + discwidth ; 
  952.           if ( t == 0 ) 
  953.           s = mem [ v ] .hh .v.RH ; 
  954.         } 
  955.         while ( s != 0 ) {
  956.         
  957.           if ( ( s >= himemmin ) ) 
  958.           goto lab30 ; 
  959.           switch ( mem [ s ] .hh.b0 ) 
  960.           {case 10 : 
  961.         {
  962.           v = mem [ s + 1 ] .hh .v.LH ; 
  963.           breakwidth [ 1 ] = breakwidth [ 1 ] - mem [ v + 1 ] .cint ; 
  964.           breakwidth [ 2 + mem [ v ] .hh.b0 ] = breakwidth [ 2 + mem [ 
  965.           v ] .hh.b0 ] - mem [ v + 2 ] .cint ; 
  966.           breakwidth [ 6 ] = breakwidth [ 6 ] - mem [ v + 3 ] .cint ; 
  967.         } 
  968.         break ; 
  969.           case 12 : 
  970.         ; 
  971.         break ; 
  972.           case 9 : 
  973.           case 11 : 
  974.         if ( mem [ s ] .hh.b1 == 2 ) 
  975.         goto lab30 ; 
  976.         else breakwidth [ 1 ] = breakwidth [ 1 ] - mem [ s + 1 ] .cint 
  977.         ; 
  978.         break ; 
  979.         default: 
  980.         goto lab30 ; 
  981.         break ; 
  982.           } 
  983.           s = mem [ s ] .hh .v.RH ; 
  984.         } 
  985.         lab30: ; 
  986.       } 
  987.       if ( mem [ prevr ] .hh.b0 == 2 ) 
  988.       {
  989.         mem [ prevr + 1 ] .cint = mem [ prevr + 1 ] .cint - curactivewidth 
  990.         [ 1 ] + breakwidth [ 1 ] ; 
  991.         mem [ prevr + 2 ] .cint = mem [ prevr + 2 ] .cint - curactivewidth 
  992.         [ 2 ] + breakwidth [ 2 ] ; 
  993.         mem [ prevr + 3 ] .cint = mem [ prevr + 3 ] .cint - curactivewidth 
  994.         [ 3 ] + breakwidth [ 3 ] ; 
  995.         mem [ prevr + 4 ] .cint = mem [ prevr + 4 ] .cint - curactivewidth 
  996.         [ 4 ] + breakwidth [ 4 ] ; 
  997.         mem [ prevr + 5 ] .cint = mem [ prevr + 5 ] .cint - curactivewidth 
  998.         [ 5 ] + breakwidth [ 5 ] ; 
  999.         mem [ prevr + 6 ] .cint = mem [ prevr + 6 ] .cint - curactivewidth 
  1000.         [ 6 ] + breakwidth [ 6 ] ; 
  1001.       } 
  1002.       else if ( prevr == memtop - 7 ) 
  1003.       {
  1004.         activewidth [ 1 ] = breakwidth [ 1 ] ; 
  1005.         activewidth [ 2 ] = breakwidth [ 2 ] ; 
  1006.         activewidth [ 3 ] = breakwidth [ 3 ] ; 
  1007.         activewidth [ 4 ] = breakwidth [ 4 ] ; 
  1008.         activewidth [ 5 ] = breakwidth [ 5 ] ; 
  1009.         activewidth [ 6 ] = breakwidth [ 6 ] ; 
  1010.       } 
  1011.       else {
  1012.           
  1013.         q = getnode ( 7 ) ; 
  1014.         mem [ q ] .hh .v.RH = r ; 
  1015.         mem [ q ] .hh.b0 = 2 ; 
  1016.         mem [ q ] .hh.b1 = 0 ; 
  1017.         mem [ q + 1 ] .cint = breakwidth [ 1 ] - curactivewidth [ 1 ] ; 
  1018.         mem [ q + 2 ] .cint = breakwidth [ 2 ] - curactivewidth [ 2 ] ; 
  1019.         mem [ q + 3 ] .cint = breakwidth [ 3 ] - curactivewidth [ 3 ] ; 
  1020.         mem [ q + 4 ] .cint = breakwidth [ 4 ] - curactivewidth [ 4 ] ; 
  1021.         mem [ q + 5 ] .cint = breakwidth [ 5 ] - curactivewidth [ 5 ] ; 
  1022.         mem [ q + 6 ] .cint = breakwidth [ 6 ] - curactivewidth [ 6 ] ; 
  1023.         mem [ prevr ] .hh .v.RH = q ; 
  1024.         prevprevr = prevr ; 
  1025.         prevr = q ; 
  1026.       } 
  1027.       if ( abs ( eqtb [ 6179 ] .cint ) >= 1073741823L - minimumdemerits ) 
  1028.       minimumdemerits = 1073741822L ; 
  1029.       else minimumdemerits = minimumdemerits + abs ( eqtb [ 6179 ] .cint ) 
  1030.       ; 
  1031.       {register integer for_end; fitclass = 0 ; for_end = 3 ; if ( 
  1032.       fitclass <= for_end) do 
  1033.         {
  1034.           if ( minimaldemerits [ fitclass ] <= minimumdemerits ) 
  1035.           {
  1036.         q = getnode ( 2 ) ; 
  1037.         mem [ q ] .hh .v.RH = passive ; 
  1038.         passive = q ; 
  1039.         mem [ q + 1 ] .hh .v.RH = curp ; 
  1040.     ;
  1041. #ifdef STAT
  1042.         incr ( passnumber ) ; 
  1043.         mem [ q ] .hh .v.LH = passnumber ; 
  1044. #endif /* STAT */
  1045.         mem [ q + 1 ] .hh .v.LH = bestplace [ fitclass ] ; 
  1046.         q = getnode ( 3 ) ; 
  1047.         mem [ q + 1 ] .hh .v.RH = passive ; 
  1048.         mem [ q + 1 ] .hh .v.LH = bestplline [ fitclass ] + 1 ; 
  1049.         mem [ q ] .hh.b1 = fitclass ; 
  1050.         mem [ q ] .hh.b0 = breaktype ; 
  1051.         mem [ q + 2 ] .cint = minimaldemerits [ fitclass ] ; 
  1052.         mem [ q ] .hh .v.RH = r ; 
  1053.         mem [ prevr ] .hh .v.RH = q ; 
  1054.         prevr = q ; 
  1055.     ;
  1056. #ifdef STAT
  1057.         if ( eqtb [ 6195 ] .cint > 0 ) 
  1058.         {
  1059.           printnl ( 918 ) ; 
  1060.           printint ( mem [ passive ] .hh .v.LH ) ; 
  1061.           print ( 919 ) ; 
  1062.           printint ( mem [ q + 1 ] .hh .v.LH - 1 ) ; 
  1063.           printchar ( 46 ) ; 
  1064.           printint ( fitclass ) ; 
  1065.           if ( breaktype == 1 ) 
  1066.           printchar ( 45 ) ; 
  1067.           print ( 920 ) ; 
  1068.           printint ( mem [ q + 2 ] .cint ) ; 
  1069.           print ( 921 ) ; 
  1070.           if ( mem [ passive + 1 ] .hh .v.LH == 0 ) 
  1071.           printchar ( 48 ) ; 
  1072.           else printint ( mem [ mem [ passive + 1 ] .hh .v.LH ] .hh 
  1073.           .v.LH ) ; 
  1074.         } 
  1075. #endif /* STAT */
  1076.           } 
  1077.           minimaldemerits [ fitclass ] = 1073741823L ; 
  1078.         } 
  1079.       while ( fitclass++ < for_end ) ; } 
  1080.       minimumdemerits = 1073741823L ; 
  1081.       if ( r != memtop - 7 ) 
  1082.       {
  1083.         q = getnode ( 7 ) ; 
  1084.         mem [ q ] .hh .v.RH = r ; 
  1085.         mem [ q ] .hh.b0 = 2 ; 
  1086.         mem [ q ] .hh.b1 = 0 ; 
  1087.         mem [ q + 1 ] .cint = curactivewidth [ 1 ] - breakwidth [ 1 ] ; 
  1088.         mem [ q + 2 ] .cint = curactivewidth [ 2 ] - breakwidth [ 2 ] ; 
  1089.         mem [ q + 3 ] .cint = curactivewidth [ 3 ] - breakwidth [ 3 ] ; 
  1090.         mem [ q + 4 ] .cint = curactivewidth [ 4 ] - breakwidth [ 4 ] ; 
  1091.         mem [ q + 5 ] .cint = curactivewidth [ 5 ] - breakwidth [ 5 ] ; 
  1092.         mem [ q + 6 ] .cint = curactivewidth [ 6 ] - breakwidth [ 6 ] ; 
  1093.         mem [ prevr ] .hh .v.RH = q ; 
  1094.         prevprevr = prevr ; 
  1095.         prevr = q ; 
  1096.       } 
  1097.     } 
  1098.     if ( r == memtop - 7 ) 
  1099.     goto lab10 ; 
  1100.     if ( l > easyline ) 
  1101.     {
  1102.       linewidth = secondwidth ; 
  1103.       oldl = 65534L ; 
  1104.     } 
  1105.     else {
  1106.         
  1107.       oldl = l ; 
  1108.       if ( l > lastspecialline ) 
  1109.       linewidth = secondwidth ; 
  1110.       else if ( eqtb [ 4312 ] .hh .v.RH == 0 ) 
  1111.       linewidth = firstwidth ; 
  1112.       else linewidth = mem [ eqtb [ 4312 ] .hh .v.RH + 2 * l ] .cint ; 
  1113.     } 
  1114.       } 
  1115.     } 
  1116.     {
  1117.       artificialdemerits = false ; 
  1118.       shortfall = linewidth - curactivewidth [ 1 ] ; 
  1119.       if ( shortfall > 0 ) 
  1120.       if ( ( curactivewidth [ 3 ] != 0 ) || ( curactivewidth [ 4 ] != 0 ) || ( 
  1121.       curactivewidth [ 5 ] != 0 ) ) 
  1122.       {
  1123.     b = 0 ; 
  1124.     fitclass = 2 ; 
  1125.       } 
  1126.       else {
  1127.       
  1128.     if ( shortfall > 7230584L ) 
  1129.     if ( curactivewidth [ 2 ] < 1663497L ) 
  1130.     {
  1131.       b = 10000 ; 
  1132.       fitclass = 0 ; 
  1133.       goto lab31 ; 
  1134.     } 
  1135.     b = badness ( shortfall , curactivewidth [ 2 ] ) ; 
  1136.     if ( b > 12 ) 
  1137.     if ( b > 99 ) 
  1138.     fitclass = 0 ; 
  1139.     else fitclass = 1 ; 
  1140.     else fitclass = 2 ; 
  1141.     lab31: ; 
  1142.       } 
  1143.       else {
  1144.       
  1145.     if ( - (integer) shortfall > curactivewidth [ 6 ] ) 
  1146.     b = 10001 ; 
  1147.     else b = badness ( - (integer) shortfall , curactivewidth [ 6 ] ) ; 
  1148.     if ( b > 12 ) 
  1149.     fitclass = 3 ; 
  1150.     else fitclass = 2 ; 
  1151.       } 
  1152.       if ( ( b > 10000 ) || ( pi == -10000 ) ) 
  1153.       {
  1154.     if ( finalpass && ( minimumdemerits == 1073741823L ) && ( mem [ r ] 
  1155.     .hh .v.RH == memtop - 7 ) && ( prevr == memtop - 7 ) ) 
  1156.     artificialdemerits = true ; 
  1157.     else if ( b > threshold ) 
  1158.     goto lab60 ; 
  1159.     noderstaysactive = false ; 
  1160.       } 
  1161.       else {
  1162.       
  1163.     prevr = r ; 
  1164.     if ( b > threshold ) 
  1165.     goto lab22 ; 
  1166.     noderstaysactive = true ; 
  1167.       } 
  1168.       if ( artificialdemerits ) 
  1169.       d = 0 ; 
  1170.       else {
  1171.       
  1172.     d = eqtb [ 6165 ] .cint + b ; 
  1173.     if ( abs ( d ) >= 10000 ) 
  1174.     d = 100000000L ; 
  1175.     else d = d * d ; 
  1176.     if ( pi != 0 ) 
  1177.     if ( pi > 0 ) 
  1178.     d = d + pi * pi ; 
  1179.     else if ( pi > -10000 ) 
  1180.     d = d - pi * pi ; 
  1181.     if ( ( breaktype == 1 ) && ( mem [ r ] .hh.b0 == 1 ) ) 
  1182.     if ( curp != 0 ) 
  1183.     d = d + eqtb [ 6177 ] .cint ; 
  1184.     else d = d + eqtb [ 6178 ] .cint ; 
  1185.     if ( abs ( toint ( fitclass ) - toint ( mem [ r ] .hh.b1 ) ) > 1 ) 
  1186.     d = d + eqtb [ 6179 ] .cint ; 
  1187.       } 
  1188.     ;
  1189. #ifdef STAT
  1190.       if ( eqtb [ 6195 ] .cint > 0 ) 
  1191.       {
  1192.     if ( printednode != curp ) 
  1193.     {
  1194.       printnl ( 335 ) ; 
  1195.       if ( curp == 0 ) 
  1196.       shortdisplay ( mem [ printednode ] .hh .v.RH ) ; 
  1197.       else {
  1198.           
  1199.         savelink = mem [ curp ] .hh .v.RH ; 
  1200.         mem [ curp ] .hh .v.RH = 0 ; 
  1201.         printnl ( 335 ) ; 
  1202.         shortdisplay ( mem [ printednode ] .hh .v.RH ) ; 
  1203.         mem [ curp ] .hh .v.RH = savelink ; 
  1204.       } 
  1205.       printednode = curp ; 
  1206.     } 
  1207.     printnl ( 64 ) ; 
  1208.     if ( curp == 0 ) 
  1209.     printesc ( 593 ) ; 
  1210.     else if ( mem [ curp ] .hh.b0 != 10 ) 
  1211.     {
  1212.       if ( mem [ curp ] .hh.b0 == 12 ) 
  1213.       printesc ( 527 ) ; 
  1214.       else if ( mem [ curp ] .hh.b0 == 7 ) 
  1215.       printesc ( 346 ) ; 
  1216.       else if ( mem [ curp ] .hh.b0 == 11 ) 
  1217.       printesc ( 337 ) ; 
  1218.       else printesc ( 340 ) ; 
  1219.     } 
  1220.     print ( 922 ) ; 
  1221.     if ( mem [ r + 1 ] .hh .v.RH == 0 ) 
  1222.     printchar ( 48 ) ; 
  1223.     else printint ( mem [ mem [ r + 1 ] .hh .v.RH ] .hh .v.LH ) ; 
  1224.     print ( 923 ) ; 
  1225.     if ( b > 10000 ) 
  1226.     printchar ( 42 ) ; 
  1227.     else printint ( b ) ; 
  1228.     print ( 924 ) ; 
  1229.     printint ( pi ) ; 
  1230.     print ( 925 ) ; 
  1231.     if ( artificialdemerits ) 
  1232.     printchar ( 42 ) ; 
  1233.     else printint ( d ) ; 
  1234.       } 
  1235. #endif /* STAT */
  1236.       d = d + mem [ r + 2 ] .cint ; 
  1237.       if ( d <= minimaldemerits [ fitclass ] ) 
  1238.       {
  1239.     minimaldemerits [ fitclass ] = d ; 
  1240.     bestplace [ fitclass ] = mem [ r + 1 ] .hh .v.RH ; 
  1241.     bestplline [ fitclass ] = l ; 
  1242.     if ( d < minimumdemerits ) 
  1243.     minimumdemerits = d ; 
  1244.       } 
  1245.       if ( noderstaysactive ) 
  1246.       goto lab22 ; 
  1247.       lab60: mem [ prevr ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  1248.       freenode ( r , 3 ) ; 
  1249.       if ( prevr == memtop - 7 ) 
  1250.       {
  1251.     r = mem [ memtop - 7 ] .hh .v.RH ; 
  1252.     if ( mem [ r ] .hh.b0 == 2 ) 
  1253.     {
  1254.       activewidth [ 1 ] = activewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  1255.       activewidth [ 2 ] = activewidth [ 2 ] + mem [ r + 2 ] .cint ; 
  1256.       activewidth [ 3 ] = activewidth [ 3 ] + mem [ r + 3 ] .cint ; 
  1257.       activewidth [ 4 ] = activewidth [ 4 ] + mem [ r + 4 ] .cint ; 
  1258.       activewidth [ 5 ] = activewidth [ 5 ] + mem [ r + 5 ] .cint ; 
  1259.       activewidth [ 6 ] = activewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  1260.       curactivewidth [ 1 ] = activewidth [ 1 ] ; 
  1261.       curactivewidth [ 2 ] = activewidth [ 2 ] ; 
  1262.       curactivewidth [ 3 ] = activewidth [ 3 ] ; 
  1263.       curactivewidth [ 4 ] = activewidth [ 4 ] ; 
  1264.       curactivewidth [ 5 ] = activewidth [ 5 ] ; 
  1265.       curactivewidth [ 6 ] = activewidth [ 6 ] ; 
  1266.       mem [ memtop - 7 ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  1267.       freenode ( r , 7 ) ; 
  1268.     } 
  1269.       } 
  1270.       else if ( mem [ prevr ] .hh.b0 == 2 ) 
  1271.       {
  1272.     r = mem [ prevr ] .hh .v.RH ; 
  1273.     if ( r == memtop - 7 ) 
  1274.     {
  1275.       curactivewidth [ 1 ] = curactivewidth [ 1 ] - mem [ prevr + 1 ] 
  1276.       .cint ; 
  1277.       curactivewidth [ 2 ] = curactivewidth [ 2 ] - mem [ prevr + 2 ] 
  1278.       .cint ; 
  1279.       curactivewidth [ 3 ] = curactivewidth [ 3 ] - mem [ prevr + 3 ] 
  1280.       .cint ; 
  1281.       curactivewidth [ 4 ] = curactivewidth [ 4 ] - mem [ prevr + 4 ] 
  1282.       .cint ; 
  1283.       curactivewidth [ 5 ] = curactivewidth [ 5 ] - mem [ prevr + 5 ] 
  1284.       .cint ; 
  1285.       curactivewidth [ 6 ] = curactivewidth [ 6 ] - mem [ prevr + 6 ] 
  1286.       .cint ; 
  1287.       mem [ prevprevr ] .hh .v.RH = memtop - 7 ; 
  1288.       freenode ( prevr , 7 ) ; 
  1289.       prevr = prevprevr ; 
  1290.     } 
  1291.     else if ( mem [ r ] .hh.b0 == 2 ) 
  1292.     {
  1293.       curactivewidth [ 1 ] = curactivewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  1294.       curactivewidth [ 2 ] = curactivewidth [ 2 ] + mem [ r + 2 ] .cint ; 
  1295.       curactivewidth [ 3 ] = curactivewidth [ 3 ] + mem [ r + 3 ] .cint ; 
  1296.       curactivewidth [ 4 ] = curactivewidth [ 4 ] + mem [ r + 4 ] .cint ; 
  1297.       curactivewidth [ 5 ] = curactivewidth [ 5 ] + mem [ r + 5 ] .cint ; 
  1298.       curactivewidth [ 6 ] = curactivewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  1299.       mem [ prevr + 1 ] .cint = mem [ prevr + 1 ] .cint + mem [ r + 1 ] 
  1300.       .cint ; 
  1301.       mem [ prevr + 2 ] .cint = mem [ prevr + 2 ] .cint + mem [ r + 2 ] 
  1302.       .cint ; 
  1303.       mem [ prevr + 3 ] .cint = mem [ prevr + 3 ] .cint + mem [ r + 3 ] 
  1304.       .cint ; 
  1305.       mem [ prevr + 4 ] .cint = mem [ prevr + 4 ] .cint + mem [ r + 4 ] 
  1306.       .cint ; 
  1307.       mem [ prevr + 5 ] .cint = mem [ prevr + 5 ] .cint + mem [ r + 5 ] 
  1308.       .cint ; 
  1309.       mem [ prevr + 6 ] .cint = mem [ prevr + 6 ] .cint + mem [ r + 6 ] 
  1310.       .cint ; 
  1311.       mem [ prevr ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  1312.       freenode ( r , 7 ) ; 
  1313.     } 
  1314.       } 
  1315.     } 
  1316.   } 
  1317.   lab10: 
  1318.     ;
  1319. #ifdef STAT
  1320.   if ( curp == printednode ) 
  1321.   if ( curp != 0 ) 
  1322.   if ( mem [ curp ] .hh.b0 == 7 ) 
  1323.   {
  1324.     t = mem [ curp ] .hh.b1 ; 
  1325.     while ( t > 0 ) {
  1326.     
  1327.       decr ( t ) ; 
  1328.       printednode = mem [ printednode ] .hh .v.RH ; 
  1329.     } 
  1330.   } 
  1331. #endif /* STAT */
  1332. } 
  1333.