src/texsourc/tex5.c

   1 #ifdef _WINDOWS
   2   #define NOCOMM
   3   #define NOSOUND
   4   #define NODRIVERS
   5   #define STRICT
   6   #pragma warning(disable:4115) // kill rpcasync.h complaint
   7   #include <windows.h>
   8   #define MYLIBAPI __declspec(dllexport)
   9 #endif
  10
  11 #include "texwin.h"
  12
  13 #pragma warning(disable:4131) // old style declarator
  14 #pragma warning(disable:4135) // conversion between different integral types
  15 #pragma warning(disable:4127) // conditional expression is constant
  16
  17 #include <setjmp.h>
  18
  19 #define EXTERN extern
  20
  21 #include "texd.h"
  22
  23 #pragma warning(disable:4244)       /* 96/Jan/10 */
  24
  25
  26 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  27
  28 /* rebox_ used to be in tex4.c */
  29
  30 halfword rebox_(halfword b, scaled w)
  31 {register halfword Result;
  32   halfword p;
  33   internal_font_number f;
  34   scaled v;
  35 /* begin if (width(b)<>w)and(list_ptr(b)<>null) then l.14010 */
  36   if ((mem[b + 1].cint != w) && (mem[b + 5].hh.v.RH != 0)) {
  37     if (mem[b].hh.b0 == 1)
  38       b = hpack(b, 0, 1);
  39     p = mem[b + 5].hh.v.RH;
  40 /*  if (is_char_node(p))and(link(p)=null) then l.14013 */
  41     if (((p >= hi_mem_min)) &&(mem[p].hh.v.RH == 0)) {
  42       f = mem[p].hh.b0;
  43       v = font_info[width_base[f]+ font_info[char_base[f]+ mem[p].hh.b1].qqqq.b0].cint;
  44       if (v != mem[b + 1].cint)
  45         mem[p].hh.v.RH = new_kern(mem[b + 1].cint - v);
  46     }
  47     free_node(b, 7);
  48     b = new_glue(12);
  49     mem[b].hh.v.RH = p;
  50 /*   while link(p)<>null do p:=link(p); l.14019 */
  51     while (mem[p].hh.v.RH != 0) p = mem[p].hh.v.RH;
  52     mem[p].hh.v.RH = new_glue(12);
  53     Result = hpack(b, w, 0);
  54   } else {
  55     mem[b + 1].cint = w;
  56     Result = b;
  57   }
  58   return Result;
  59 }
  60 /* This is to be the start of tex5.c */
  61 halfword math_glue_(halfword g, scaled m)
  62 {
  63   register halfword Result;
  64   halfword p;
  65   integer n;
  66   scaled f;
  67   n = x_over_n(m, 65536L);
  68   f = tex_remainder;
  69   if (f < 0) {
  70     decr(n);
  71     f = f + 65536L;
  72   }
  73   p = get_node(4);
  74   mem[p + 1].cint = mult_and_add(n, mem[g + 1].cint, xn_over_d(mem[g + 1].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
  75   mem[p].hh.b0 = mem[g].hh.b0;
  76   if (mem[p].hh.b0 == 0)
  77     mem[p + 2].cint = mult_and_add(n, mem[g + 2].cint, xn_over_d(mem[g + 2].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
  78   else
  79     mem[p + 2].cint = mem[g + 2].cint;
  80   mem[p].hh.b1 = mem[g].hh.b1;
  81   if (mem[p].hh.b1 == 0)
  82     mem[p + 3].cint = mult_and_add(n, mem[g + 3].cint, xn_over_d(mem[g + 3].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
  83   else
  84     mem[p + 3].cint = mem[g + 3].cint;
  85   Result = p;
  86   return Result;
  87 }
  88 void math_kern_ (halfword p, scaled m)
  89 {
  90   integer n;
  91   scaled f;
  92   if (mem[p].hh.b1 == 99)
  93   {
  94     n = x_over_n(m, 65536L);
  95     f = tex_remainder;
  96     if (f < 0)
  97     {
  98       decr(n);
  99       f = f + 65536L;
 100     }
 101     mem[p + 1].cint = mult_and_add(n, mem[p + 1].cint, xn_over_d(mem
 102    [p + 1].cint, f, 65536L), 1073741823L);  /* 2^30 - 1 */
 103 /*    mem[p].hh.b1 = 0;  */
 104     mem[p].hh.b1 = 1; /* changed in 3.14159 */
 105   }
 106 }
 107 void flush_math (void)
 108 {
 109   flush_node_list(mem[head].hh.v.RH);
 110   flush_node_list(cur_list.aux_field.cint);
 111   mem[head].hh.v.RH = 0;
 112   tail = head;
 113   cur_list.aux_field.cint = 0;
 114 }
 115 halfword clean_box_(halfword p, small_number s)
 116 {/* 40 */ register halfword Result;
 117   halfword q;
 118   small_number savestyle;
 119   halfword x;
 120   halfword r;
 121   switch(mem[p].hh.v.RH)
 122   {case 1 :
 123     {
 124       cur_mlist = new_noad();
 125       mem[cur_mlist + 1]= mem[p];
 126     }
 127     break;
 128   case 2 :
 129     {
 130       q = mem[p].hh.v.LH;
 131       goto lab40;
 132     }
 133     break;
 134   case 3 :
 135     cur_mlist = mem[p].hh.v.LH;
 136     break;
 137     default:
 138     {
 139       q = new_null_box();
 140       goto lab40;
 141     }
 142     break;
 143   }
 144   savestyle = cur_style;
 145   cur_style = s;
 146   mlist_penalties = false;
 147   mlist_to_hlist();
 148   q = mem[temp_head].hh.v.RH;
 149   cur_style = savestyle;
 150   {
 151     if (cur_style < 4)
 152     cur_size = 0;
 153     else cur_size = 16 *((cur_style - 2)/ 2);
 154     cur_mu = x_over_n(font_info[6 +
 155     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint, 18);
 156   }
 157   lab40: if ((q >= hi_mem_min)||(q == 0))
 158   x = hpack(q, 0, 1);
 159   else if ((mem[q].hh.v.RH == 0)&&(mem[q].hh.b0 <= 1)&&(mem
 160  [q + 4].cint == 0))
 161   x = q;
 162   else x = hpack(q, 0, 1);
 163   q = mem[x + 5].hh.v.RH;
 164   if ((q >= hi_mem_min))
 165   {
 166     r = mem[q].hh.v.RH;
 167 /*   if r<>null then if link(r)=null then l.14140 */
 168     if (r != 0)
 169     if (mem[r].hh.v.RH == 0)
 170     if (!(r >= hi_mem_min))
 171     if (mem[r].hh.b0 == 11)
 172     {
 173       free_node(r, 2);
 174       mem[q].hh.v.RH = 0;   /* link(q):=null; */
 175     }
 176   }
 177   Result = x;
 178   return Result;
 179 }
 180 void fetch_(halfword a)
 181 {
 182   cur_c = mem[a].hh.b1;
 183   cur_f = eqtb[(hash_size + 1835) + mem[a].hh.b0 + cur_size].hh.v.RH;
 184   if (cur_f == 0)
 185   {
 186           print_err("");
 187     print_size(cur_size);
 188     print_char(' ');
 189     print_int(mem[a].hh.b0);
 190     print_string("is undefined (character ");
 191     print(cur_c);
 192     print_char(')');
 193         help4("Somewhere in the math formula just ended, you used the",
 194                 "stated character from an undefined font family. For example,",
 195                 "plain TeX doesn't allow \\it or \\sl in subscripts. Proceed,",
 196                 "and I'll try to forget that I needed that character.");
 197     error();
 198     cur_i = null_character;
 199     mem[a].hh.v.RH = 0;
 200   }
 201   else {
 202
 203     if ((cur_c >= font_bc[cur_f])&&(cur_c <= font_ec[cur_f]))
 204     cur_i = font_info[char_base[cur_f]+ cur_c].qqqq;
 205     else cur_i = null_character;
 206     if (!((cur_i.b0 > 0)))
 207     {
 208       char_warning(cur_f, cur_c);
 209       mem[a].hh.v.RH = 0;
 210     }
 211   }
 212 }
 213 void make_over_(halfword q)
 214 {
 215   mem[q + 1].hh.v.LH = overbar(clean_box(q + 1, 2 *(cur_style / 2)
 216   + 1), 3 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]
 217 ].cint, font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]]
 218  .cint);
 219   mem[q + 1].hh.v.RH = 2;
 220 }
 221 void make_under_(halfword q)
 222 {
 223   halfword p, x, y;
 224   scaled delta;
 225   x = clean_box(q + 1, cur_style);
 226   p = new_kern(3 * font_info[8 +
 227     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint);
 228   mem[x].hh.v.RH = p;
 229   mem[p].hh.v.RH = fraction_rule(font_info[8 +
 230     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint);
 231   y = vpackage(x, 0, 1, 1073741823L); /* 2^30 - 1 */
 232   delta = mem[y + 3].cint + mem[y + 2].cint + font_info[8 +
 233     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint;
 234   mem[y + 3].cint = mem[x + 3].cint;
 235   mem[y + 2].cint = delta - mem[y + 3].cint;
 236   mem[q + 1].hh.v.LH = y;
 237   mem[q + 1].hh.v.RH = 2;
 238 }
 239 void make_vcenter_(halfword q)
 240 {
 241   halfword v;
 242   scaled delta;
 243   v = mem[q + 1].hh.v.LH;
 244   if (mem[v].hh.b0 != 1){
 245     confusion("vcenter");
 246     return;         // abort_flag set
 247   }
 248   delta = mem[v + 3].cint + mem[v + 2].cint;
 249   mem[v + 3].cint = font_info[22 +
 250     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint + half(delta);
 251   mem[v + 2].cint = delta - mem[v + 3].cint;
 252 }
 253 void make_radical_(halfword q)
 254 {
 255   halfword x, y;
 256   scaled delta, clr;
 257   x = clean_box(q + 1, 2 *(cur_style / 2)+ 1);
 258   if (cur_style < 2)
 259   clr = font_info[8 +
 260   param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint +
 261     (abs(font_info[5 + param_base[eqtb[(hash_size + 1837) +
 262         cur_size].hh.v.RH]].cint)/ 4);
 263   else {
 264
 265     clr = font_info[8 +
 266       param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint;
 267     clr = clr +(abs(clr)/ 4);
 268   }
 269   y = var_delimiter(q + 4, cur_size, mem[x + 3].cint + mem[x + 2]
 270  .cint + clr + font_info[8 +
 271     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint);
 272   delta = mem[y + 2].cint -(mem[x + 3].cint + mem[x + 2].cint +
 273   clr);
 274   if (delta > 0)
 275   clr = clr + half(delta);
 276   mem[y + 4].cint = - (integer)(mem[x + 3].cint + clr);
 277   mem[y].hh.v.RH = overbar(x, clr, mem[y + 3].cint);
 278   mem[q + 1].hh.v.LH = hpack(y, 0, 1);
 279   mem[q + 1].hh.v.RH = 2;
 280 }
 281 void make_math_accent_(halfword q)
 282 {/* 30 31 */
 283   halfword p, x, y;
 284   integer a;
 285   quarterword c;
 286   internal_font_number f;
 287   ffourquarters i;
 288   scaled s;
 289   scaled h;
 290   scaled delta;
 291   scaled w;
 292   fetch(q + 4);
 293   if ((cur_i.b0 > 0))
 294   {
 295     i = cur_i;
 296     c = cur_c;
 297     f = cur_f;
 298     s = 0;
 299     if (mem[q + 1].hh.v.RH == 1)
 300     {
 301       fetch(q + 1);
 302       if (((cur_i.b2)% 4)== 1)
 303       {
 304   a = lig_kern_base[cur_f]+ cur_i.b3;
 305   cur_i = font_info[a].qqqq;
 306   if (cur_i.b0 > 128)
 307   {
 308     a = lig_kern_base[cur_f]+ 256 * cur_i.b2 + cur_i.b3 + 32768L - 256
 309     *(128);
 310     cur_i = font_info[a].qqqq;
 311   }
 312   while(true){
 313     if (cur_i.b1 == skew_char[cur_f])
 314     {
 315       if (cur_i.b2 >= 128)
 316       if (cur_i.b0 <= 128)
 317       s = font_info[kern_base[cur_f]+ 256 * cur_i.b2 + cur_i.b3]
 318      .cint;
 319       goto lab31;
 320     }
 321     if (cur_i.b0 >= 128)
 322     goto lab31;
 323     a = a + cur_i.b0 + 1;
 324     cur_i = font_info[a].qqqq;
 325   }
 326       }
 327     }
 328     lab31:;
 329     x = clean_box(q + 1, 2 *(cur_style / 2)+ 1);
 330     w = mem[x + 1].cint;
 331     h = mem[x + 3].cint;
 332     while(true){
 333       if (((i.b2)% 4)!= 2)
 334       goto lab30;
 335       y = i.b3;
 336       i = font_info[char_base[f]+ y].qqqq;
 337       if (!(i.b0 > 0))
 338       goto lab30;
 339       if (font_info[width_base[f]+ i.b0].cint > w)
 340       goto lab30;
 341 /*    long to unsigned short ... */
 342       c = y;
 343     }
 344     lab30:;
 345     if (h < font_info[5 + param_base[f]].cint)
 346     delta = h;
 347     else delta = font_info[5 + param_base[f]].cint;
 348     if ((mem[q + 2].hh.v.RH != 0)||(mem[q + 3].hh.v.RH != 0)
 349   )
 350     if (mem[q + 1].hh.v.RH == 1)
 351     {
 352       flush_node_list(x);
 353       x = new_noad();
 354       mem[x + 1]= mem[q + 1];
 355       mem[x + 2]= mem[q + 2];
 356       mem[x + 3]= mem[q + 3];
 357       mem[q + 2].hh = empty_field;
 358       mem[q + 3].hh = empty_field;
 359       mem[q + 1].hh.v.RH = 3;
 360       mem[q + 1].hh.v.LH = x;
 361       x = clean_box(q + 1, cur_style);
 362       delta = delta + mem[x + 3].cint - h;
 363       h = mem[x + 3].cint;
 364     }
 365     y = char_box(f, c);
 366     mem[y + 4].cint = s + half(w - mem[y + 1].cint);
 367     mem[y + 1].cint = 0;
 368     p = new_kern(- (integer) delta);
 369     mem[p].hh.v.RH = x;
 370     mem[y].hh.v.RH = p;
 371     y = vpackage(y, 0, 1, 1073741823L);  /* 2^30 - 1 */
 372     mem[y + 1].cint = mem[x + 1].cint;
 373     if (mem[y + 3].cint < h)
 374     {
 375       p = new_kern(h - mem[y + 3].cint);
 376       mem[p].hh.v.RH = mem[y + 5].hh.v.RH;
 377       mem[y + 5].hh.v.RH = p;
 378       mem[y + 3].cint = h;
 379     }
 380     mem[q + 1].hh.v.LH = y;
 381     mem[q + 1].hh.v.RH = 2;
 382   }
 383 }
 384 void make_fraction_(halfword q)
 385 {
 386   halfword p, v, x, y, z;
 387   scaled delta, delta1, delta2, shiftup, shiftdown, clr;
 388   if (mem[q + 1].cint == 1073741824L) /* 2^30 */
 389   mem[q + 1].cint = font_info[8 +
 390     param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint;
 391   x = clean_box(q + 2, cur_style + 2 - 2 *(cur_style / 6));
 392   z = clean_box(q + 3, 2 *(cur_style / 2)+ 3 - 2 *(cur_style / 6));
 393   if (mem[x + 1].cint < mem[z + 1].cint)
 394   x = rebox(x, mem[z + 1].cint);
 395   else z = rebox(z, mem[x + 1].cint);
 396   if (cur_style < 2)
 397   {
 398     shiftup = font_info[8 +
 399       param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 400     shiftdown = font_info[11 +
 401     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 402   }
 403   else {
 404
 405     shiftdown = font_info[12 +
 406     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 407     if (mem[q + 1].cint != 0)
 408     shiftup = font_info[9 +
 409     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 410     else shiftup = font_info[10 +
 411     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
 412   }
 413   if (mem[q + 1].cint == 0)
 414   {
 415     if (cur_style < 2)
 416     clr = 7 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH]
 417   ].cint;
 418     else clr = 3 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
 419    .v.RH]].cint;
 420     delta = half(clr -((shiftup - mem[x + 2].cint)-(mem[z + 3]
 421    .cint - shiftdown)));
 422     if (delta > 0)
 423     {
 424       shiftup = shiftup + delta;
 425       shiftdown = shiftdown + delta;
 426     }
 427   }
 428   else {
 429
 430     if (cur_style < 2)
 431     clr = 3 * mem[q + 1].cint;
 432     else clr = mem[q + 1].cint;
 433     delta = half(mem[q + 1].cint);
 434     delta1 = clr -((shiftup - mem[x + 2].cint)-(font_info[22 +
 435     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint + delta));
 436     delta2 = clr -((font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size]
 437    .hh.v.RH]].cint - delta)-(mem[z + 3].cint - shiftdown));
 438     if (delta1 > 0)
 439     shiftup = shiftup + delta1;
 440     if (delta2 > 0)
 441     shiftdown = shiftdown + delta2;
 442   }
 443   v = new_null_box();
 444   mem[v].hh.b0 = 1;
 445   mem[v + 3].cint = shiftup + mem[x + 3].cint;
 446   mem[v + 2].cint = mem[z + 2].cint + shiftdown;
 447   mem[v + 1].cint = mem[x + 1].cint;
 448   if (mem[q + 1].cint == 0)
 449   {
 450     p = new_kern((shiftup - mem[x + 2].cint)-(mem[z + 3].cint -
 451     shiftdown));
 452     mem[p].hh.v.RH = z;
 453   }
 454   else {
 455
 456     y = fraction_rule(mem[q + 1].cint);
 457     p = new_kern((font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 458    .v.RH]].cint - delta)-(mem[z + 3].cint - shiftdown));
 459     mem[y].hh.v.RH = p;
 460     mem[p].hh.v.RH = z;
 461     p = new_kern((shiftup - mem[x + 2].cint)-(font_info[22 +
 462     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint + delta));
 463     mem[p].hh.v.RH = y;
 464   }
 465   mem[x].hh.v.RH = p;
 466   mem[v + 5].hh.v.RH = x;
 467   if (cur_style < 2)
 468   delta = font_info[20 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]]
 469  .cint;
 470   else delta = font_info[21 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH
 471 ]].cint;
 472   x = var_delimiter(q + 4, cur_size, delta);
 473   mem[x].hh.v.RH = v;
 474   z = var_delimiter(q + 5, cur_size, delta);
 475   mem[v].hh.v.RH = z;
 476   mem[q + 1].cint = hpack(x, 0, 1);
 477 }
 478 /***************************************************************************/
 479 /* moved to end to avoid questions about pragma optimize 96/Sep/12 */
 480 scaled make_op_ (halfword);
 481 /***************************************************************************/
 482 void make_ord_(halfword q)
 483 {/* 20 10 */
 484   integer a;
 485   halfword p, r;
 486   lab20: if (mem[q + 3].hh.v.RH == 0)
 487   if (mem[q + 2].hh.v.RH == 0)
 488   if (mem[q + 1].hh.v.RH == 1)
 489   {
 490     p = mem[q].hh.v.RH;
 491     if (p != 0)
 492     if ((mem[p].hh.b0 >= 16)&&(mem[p].hh.b0 <= 22))
 493     if (mem[p + 1].hh.v.RH == 1)
 494     if (mem[p + 1].hh.b0 == mem[q + 1].hh.b0)
 495     {
 496       mem[q + 1].hh.v.RH = 4;
 497       fetch(q + 1);
 498       if (((cur_i.b2)% 4)== 1)
 499       {
 500   a = lig_kern_base[cur_f]+ cur_i.b3;
 501   cur_c = mem[p + 1].hh.b1;
 502   cur_i = font_info[a].qqqq;
 503   if (cur_i.b0 > 128)
 504   {
 505     a = lig_kern_base[cur_f]+ 256 * cur_i.b2 + cur_i.b3 + 32768L - 256
 506     *(128);
 507     cur_i = font_info[a].qqqq;
 508   }
 509   while(true){
 510     if (cur_i.b1 == cur_c)
 511     if (cur_i.b0 <= 128)
 512     if (cur_i.b2 >= 128)
 513     {
 514       p = new_kern(font_info[kern_base[cur_f]+ 256 * cur_i.b2 + cur_i
 515      .b3].cint);
 516       mem[p].hh.v.RH = mem[q].hh.v.RH;
 517       mem[q].hh.v.RH = p;
 518       return;
 519     }
 520     else {
 521
 522       {
 523         if (interrupt != 0){
 524         pause_for_instructions();
 525       }
 526       }
 527       switch(cur_i.b2)
 528       {case 1 :
 529       case 5 :
 530         mem[q + 1].hh.b1 = cur_i.b3;
 531         break;
 532       case 2 :
 533       case 6 :
 534         mem[p + 1].hh.b1 = cur_i.b3;
 535         break;
 536       case 3 :
 537       case 7 :
 538       case 11 :
 539         {
 540     r = new_noad();
 541     mem[r + 1].hh.b1 = cur_i.b3;
 542     mem[r + 1].hh.b0 = mem[q + 1].hh.b0;
 543     mem[q].hh.v.RH = r;
 544     mem[r].hh.v.RH = p;
 545     if (cur_i.b2 < 11)
 546     mem[r + 1].hh.v.RH = 1;
 547     else mem[r + 1].hh.v.RH = 4;
 548         }
 549         break;
 550         default:
 551         {
 552     mem[q].hh.v.RH = mem[p].hh.v.RH;
 553     mem[q + 1].hh.b1 = cur_i.b3;
 554     mem[q + 3]= mem[p + 3];
 555     mem[q + 2]= mem[p + 2];
 556     free_node(p, 4);
 557         }
 558         break;
 559       }
 560       if (cur_i.b2 > 3)
 561       return;
 562       mem[q + 1].hh.v.RH = 1;
 563       goto lab20;
 564     }
 565     if (cur_i.b0 >= 128)
 566     return;
 567     a = a + cur_i.b0 + 1;
 568     cur_i = font_info[a].qqqq;
 569   }
 570       }
 571     }
 572   }
 573 }
 574 /***************************************************************************/
 575 /* moved to end to avoid questions about pragma optimize 96/Sep/12 */
 576 void make_scripts_ (halfword, scaled);
 577 /***************************************************************************/
 578 small_number make_left_right_(halfword q, small_number style, scaled maxd, scaled max_h)
 579 {register small_number Result;
 580   scaled delta, delta1, delta2;
 581   if (style < 4)
 582   cur_size = 0;
 583   else cur_size = 16 *((style - 2)/ 2);
 584   delta2 = maxd + font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 585  .v.RH]].cint;
 586   delta1 = max_h + maxd - delta2;
 587   if (delta2 > delta1)
 588   delta1 = delta2;
 589   delta =(delta1 / 500) * delimiter_factor;
 590   delta2 = delta1 + delta1 - delimiter_shortfall;
 591   if (delta < delta2)
 592   delta = delta2;
 593   mem[q + 1].cint = var_delimiter(q + 1, cur_size, delta);
 594   Result = mem[q].hh.b0 -(10);
 595   return Result;
 596 }
 597 void mlist_to_hlist (void)
 598 {/* 21 82 80 81 83 30 */
 599   halfword mlist;
 600   bool penalties;
 601   small_number style;
 602   small_number savestyle;
 603   halfword q;
 604   halfword r;
 605 /*  small_number rtype;  */
 606   int rtype;            /* 95/Jan/7 */
 607 /*  small_number t; */
 608   int t;              /* 95/Jan/7 */
 609   halfword p, x, y, z;
 610   integer pen;
 611   small_number s;
 612   scaled max_h, maxd;
 613   scaled delta;
 614   mlist = cur_mlist;
 615   penalties = mlist_penalties;
 616   style = cur_style;
 617   q = mlist;
 618   r = 0;
 619   rtype = 17;
 620   max_h = 0;
 621   maxd = 0;
 622   {
 623     if (cur_style < 4)
 624     cur_size = 0;
 625     else cur_size = 16 *((cur_style - 2)/ 2);
 626     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 627    .v.RH]].cint, 18);
 628   }
 629   while(q != 0){
 630
 631     lab21: delta = 0;
 632     switch(mem[q].hh.b0){
 633     case 18 :
 634       switch(rtype)
 635       {case 18 :
 636       case 17 :
 637       case 19 :
 638       case 20 :
 639       case 22 :
 640       case 30 :
 641   {
 642     mem[q].hh.b0 = 16;
 643     goto lab21;
 644   }
 645   break;
 646   default:
 647   ;
 648   break;
 649       }
 650       break;
 651     case 19 :
 652     case 21 :
 653     case 22 :
 654     case 31 :
 655       {
 656   if (rtype == 18) mem[r].hh.b0 = 16;
 657   if (mem[q].hh.b0 == 31)  goto lab80;
 658       }
 659       break;
 660     case 30 :
 661       goto lab80;
 662       break;
 663     case 25 :
 664       {
 665   make_fraction(q);
 666   goto lab82;
 667       }
 668       break;
 669     case 17 :
 670       {
 671   delta = make_op(q);
 672   if (mem[q].hh.b1 == 1)
 673   goto lab82;
 674       }
 675       break;
 676     case 16 :
 677       make_ord(q);
 678       break;
 679     case 20 :
 680     case 23 :
 681    ;
 682       break;
 683     case 24 :
 684       make_radical(q);
 685       break;
 686     case 27 :
 687       make_over(q);
 688       break;
 689     case 26 :
 690       make_under(q);
 691       break;
 692     case 28 :
 693       make_math_accent(q);
 694       break;
 695     case 29 :
 696       make_vcenter(q);
 697       break;
 698     case 14 :
 699       {
 700   cur_style = mem[q].hh.b1;
 701   {
 702     if (cur_style < 4)
 703     cur_size = 0;
 704     else cur_size = 16 *((cur_style - 2)/ 2);
 705     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
 706    .hh.v.RH]].cint, 18);
 707   }
 708   goto lab81;
 709       }
 710       break;
 711     case 15 :
 712       {
 713   switch(cur_style / 2)
 714   {case 0 :
 715     {
 716       p = mem[q + 1].hh.v.LH;
 717       mem[q + 1].hh.v.LH = 0;
 718     }
 719     break;
 720   case 1 :
 721     {
 722       p = mem[q + 1].hh.v.RH;
 723       mem[q + 1].hh.v.RH = 0;
 724     }
 725     break;
 726   case 2 :
 727     {
 728       p = mem[q + 2].hh.v.LH;
 729       mem[q + 2].hh.v.LH = 0;
 730     }
 731     break;
 732   case 3 :
 733     {
 734       p = mem[q + 2].hh.v.RH;
 735       mem[q + 2].hh.v.RH = 0;
 736     }
 737     break;
 738   }
 739   flush_node_list(mem[q + 1].hh.v.LH);
 740   flush_node_list(mem[q + 1].hh.v.RH);
 741   flush_node_list(mem[q + 2].hh.v.LH);
 742   flush_node_list(mem[q + 2].hh.v.RH);
 743   mem[q].hh.b0 = 14;
 744   mem[q].hh.b1 = cur_style;
 745   mem[q + 1].cint = 0;
 746   mem[q + 2].cint = 0;
 747   if (p != 0)/* if p<>null then l.14317 */
 748   {
 749     z = mem[q].hh.v.RH;
 750     mem[q].hh.v.RH = p;
 751 /*   while link(p)<>null do p:=link(p); */
 752     while(mem[p].hh.v.RH != 0)p = mem[p].hh.v.RH;
 753     mem[p].hh.v.RH = z;
 754   }
 755   goto lab81;
 756       }
 757       break;
 758     case 3 :
 759     case 4 :
 760     case 5 :
 761     case 8 :
 762     case 12 :
 763     case 7 :
 764       goto lab81;
 765       break;
 766     case 2 :
 767       {
 768   if (mem[q + 3].cint > max_h)
 769   max_h = mem[q + 3].cint;
 770   if (mem[q + 2].cint > maxd)
 771   maxd = mem[q + 2].cint;
 772   goto lab81;
 773       }
 774       break;
 775     case 10 :
 776       {
 777   if (mem[q].hh.b1 == 99)
 778   {
 779     x = mem[q + 1].hh.v.LH;
 780     y = math_glue(x, cur_mu);
 781     delete_glue_ref(x);
 782     mem[q + 1].hh.v.LH = y;
 783     mem[q].hh.b1 = 0;
 784   }
 785   else if ((cur_size != 0)&&(mem[q].hh.b1 == 98))
 786   {
 787     p = mem[q].hh.v.RH;
 788 /*   if p<>null then if (type(p)=glue_node)or(type(p)=kern_node) then */
 789     if (p != 0)
 790     if ((mem[p].hh.b0 == 10)||(mem[p].hh.b0 == 11))
 791     {
 792       mem[q].hh.v.RH = mem[p].hh.v.RH;
 793       mem[p].hh.v.RH = 0;
 794       flush_node_list(p);
 795     }
 796   }
 797   goto lab81;
 798       }
 799       break;
 800     case 11 :
 801       {
 802   math_kern(q, cur_mu);
 803   goto lab81;
 804       }
 805       break;
 806       default:
 807       {
 808         confusion("mlist1");
 809         return;       // abort_flag set
 810       }
 811       break;
 812   } /* end of switch */
 813
 814     switch(mem[q + 1].hh.v.RH){
 815   case 1 :
 816     case 4 :
 817       {
 818   fetch(q + 1);
 819   if ((cur_i.b0 > 0))
 820   {
 821     delta = font_info[italic_base[cur_f]+(cur_i.b2)/ 4].cint;
 822     p = new_character(cur_f, cur_c);
 823     if ((mem[q + 1].hh.v.RH == 4)&&(font_info[2 + param_base
 824    [cur_f]].cint != 0))
 825     delta = 0;
 826     if ((mem[q + 3].hh.v.RH == 0)&&(delta != 0))
 827     {
 828       mem[p].hh.v.RH = new_kern(delta);
 829       delta = 0;
 830     }
 831   }
 832   else p = 0;
 833       }
 834       break;
 835     case 0 :
 836       p = 0;
 837       break;
 838     case 2 :
 839       p = mem[q + 1].hh.v.LH;
 840       break;
 841     case 3 :
 842       {
 843   cur_mlist = mem[q + 1].hh.v.LH;
 844   savestyle = cur_style;
 845   mlist_penalties = false;
 846   mlist_to_hlist();
 847   cur_style = savestyle;
 848   {
 849     if (cur_style < 4)
 850     cur_size = 0;
 851     else cur_size = 16 *((cur_style - 2)/ 2);
 852     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
 853    .hh.v.RH]].cint, 18);
 854   }
 855   p = hpack(mem[temp_head].hh.v.RH, 0, 1);
 856       }
 857       break;
 858       default:
 859       {
 860         confusion("mlist2");
 861         return;       // abort_flag set
 862       }
 863       break;
 864   } /* end of switch */
 865
 866     mem[q + 1].cint = p;  /* p may be used without ... */
 867     if ((mem[q + 3].hh.v.RH == 0)&&(mem[q + 2].hh.v.RH == 0)
 868   )
 869     goto lab82;
 870     make_scripts(q, delta);
 871     lab82: z = hpack(mem[q + 1].cint, 0, 1);
 872     if (mem[z + 3].cint > max_h)
 873     max_h = mem[z + 3].cint;
 874     if (mem[z + 2].cint > maxd)
 875     maxd = mem[z + 2].cint;
 876     free_node(z, 7);
 877     lab80: r = q;
 878     rtype = mem[r].hh.b0;
 879     lab81: q = mem[q].hh.v.RH;
 880   }
 881   if (rtype == 18)
 882   mem[r].hh.b0 = 16;
 883   p = temp_head;
 884   mem[p].hh.v.RH = 0;
 885   q = mlist;
 886   rtype = 0;
 887   cur_style = style;
 888   {
 889     if (cur_style < 4)
 890     cur_size = 0;
 891     else cur_size = 16 *((cur_style - 2)/ 2);
 892     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
 893    .v.RH]].cint, 18);
 894   }
 895   while(q != 0){
 896
 897     t = 16;
 898     s = 4;
 899     pen = 10000;
 900     switch(mem[q].hh.b0)
 901     {case 17 :
 902     case 20 :
 903     case 21 :
 904     case 22 :
 905     case 23 :
 906       t = mem[q].hh.b0;
 907       break;
 908     case 18 :
 909       {
 910   t = 18;
 911   pen = bin_op_penalty;
 912       }
 913       break;
 914     case 19 :
 915       {
 916   t = 19;
 917   pen = rel_penalty;
 918       }
 919       break;
 920     case 16 :
 921     case 29 :
 922     case 27 :
 923     case 26 :
 924    ;
 925       break;
 926     case 24 :
 927       s = 5;
 928       break;
 929     case 28 :
 930       s = 5;
 931       break;
 932     case 25 :
 933       {
 934   t = 23;
 935   s = 6;
 936       }
 937       break;
 938     case 30 :
 939     case 31 :
 940       t = make_left_right(q, style, maxd, max_h);
 941       break;
 942     case 14 :
 943       {
 944   cur_style = mem[q].hh.b1;
 945   s = 3;
 946   {
 947     if (cur_style < 4)
 948     cur_size = 0;
 949     else cur_size = 16 *((cur_style - 2)/ 2);
 950     cur_mu = x_over_n(font_info[6 + param_base[eqtb[(hash_size + 1837) + cur_size]
 951    .hh.v.RH]].cint, 18);
 952   }
 953   goto lab83;
 954       }
 955       break;
 956     case 8 :
 957     case 12 :
 958     case 2 :
 959     case 7 :
 960     case 5 :
 961     case 3 :
 962     case 4 :
 963     case 10 :
 964     case 11 :
 965       {
 966   mem[p].hh.v.RH = q;
 967   p = q;
 968   q = mem[q].hh.v.RH;
 969   mem[p].hh.v.RH = 0;
 970   goto lab30;
 971       }
 972       break;
 973       default:
 974       {
 975         confusion("mlist3");
 976         return;       // abort_flag set
 977       }
 978       break;
 979     }
 980     if (rtype > 0)
 981     {
 982       switch(str_pool[rtype * 8 + t + magic_offset])
 983       {case 48 :
 984   x = 0;
 985   break;
 986       case 49 :
 987   if (cur_style < 4)
 988   x = 15;
 989   else x = 0;
 990   break;
 991       case 50 :
 992   x = 15;
 993   break;
 994       case 51 :
 995   if (cur_style < 4)
 996   x = 16;
 997   else x = 0;
 998   break;
 999       case 52 :
1000   if (cur_style < 4)
1001   x = 17;
1002   else x = 0;
1003   break;
1004   default:
1005     {
1006       confusion("mlist4");
1007       return;       // abort_flag set
1008     }
1009     break;
1010       }
1011       if (x != 0)
1012       {
1013   y = math_glue(eqtb[(hash_size + 782) + x].hh.v.RH, cur_mu); /* gluebase + x */
1014   z = new_glue(y);
1015   mem[y].hh.v.RH = 0;
1016   mem[p].hh.v.RH = z;
1017   p = z;
1018   mem[z].hh.b1 = x + 1;   /* x may be used without ... */
1019       }
1020     }
1021     if (mem[q + 1].cint != 0)
1022     {
1023       mem[p].hh.v.RH = mem[q + 1].cint;
1024       do {
1025     p = mem[p].hh.v.RH;
1026       } while(!(mem[p].hh.v.RH == 0));
1027     }
1028     if (penalties)
1029     if (mem[q].hh.v.RH != 0)
1030     if (pen < 10000)
1031     {
1032       rtype = mem[mem[q].hh.v.RH].hh.b0;
1033       if (rtype != 12)
1034       if (rtype != 19)
1035       {
1036   z = new_penalty(pen);
1037   mem[p].hh.v.RH = z;
1038   p = z;
1039       }
1040     }
1041     rtype = t;
1042     lab83: r = q;
1043     q = mem[q].hh.v.RH;
1044     free_node(r, s);
1045     lab30:;
1046   }
1047 }
1048 void push_alignment (void)
1049 {
1050   halfword p;
1051   p = get_node(5);
1052   mem[p].hh.v.RH = align_ptr;
1053   mem[p].hh.v.LH = cur_align;
1054   mem[p + 1].hh.v.LH = mem[align_head].hh.v.RH;
1055   mem[p + 1].hh.v.RH = cur_span;
1056   mem[p + 2].cint = cur_loop;
1057   mem[p + 3].cint = align_state;
1058   mem[p + 4].hh.v.LH = cur_head;
1059   mem[p + 4].hh.v.RH = cur_tail;
1060   align_ptr = p;
1061   cur_head = get_avail();
1062 }
1063 void pop_alignment (void)
1064 {
1065   halfword p;
1066   {
1067     mem[cur_head].hh.v.RH = avail;
1068     avail = cur_head;
1069   ;
1070 #ifdef STAT
1071     decr(dyn_used);
1072 #endif /* STAT */
1073   }
1074   p = align_ptr;
1075   cur_tail = mem[p + 4].hh.v.RH;
1076   cur_head = mem[p + 4].hh.v.LH;
1077   align_state = mem[p + 3].cint;
1078   cur_loop = mem[p + 2].cint;
1079   cur_span = mem[p + 1].hh.v.RH;
1080   mem[align_head].hh.v.RH = mem[p + 1].hh.v.LH;
1081   cur_align = mem[p].hh.v.LH;
1082   align_ptr = mem[p].hh.v.RH;
1083   free_node(p, 5);
1084 }
1085 void get_preamble_token (void)
1086 {/* 20 */
1087   lab20: get_token();
1088   while((cur_chr == 256)&&(cur_cmd == 4)) {
1089
1090     get_token();
1091     if (cur_cmd > 100)
1092     {
1093       expand();
1094       get_token();
1095     }
1096   }
1097   if (cur_cmd == 9){
1098     fatal_error("(interwoven alignment preambles are not allowed)"); /*  */
1099     return;     // abort_flag set
1100   }
1101   if ((cur_cmd == 75)&&(cur_chr == (hash_size + 793)))
1102   {
1103     scan_optional_equals();
1104     scan_glue(2);
1105     if (global_defs > 0)
1106     geq_define((hash_size + 793), 117, cur_val);
1107     else eq_define((hash_size + 793), 117, cur_val);
1108     goto lab20;
1109   }
1110 }
1111 void init_align (void)
1112 {/* 30 31 32 22 */
1113   halfword savecsptr;
1114   halfword p;
1115   savecsptr = cur_cs;
1116   push_alignment();
1117   align_state = -1000000L;
1118   if ((mode == 203)&&((tail != cur_list
1119  .head_field)||(cur_list.aux_field.cint != 0)))
1120   {
1121           print_err("Improper ");
1122     print_esc("halign");
1123     print_string("inside $$");
1124         help3("Displays can use special alignments (like \\eqalignno)",
1125                 "only if nothing but the alignment itself is between $$'s.",
1126                 "So I've deleted the formulas that preceded this alignment.");
1127     error();
1128     flush_math();
1129   }
1130   push_nest();
1131   if (mode == 203)
1132   {
1133     mode = -1;
1134     cur_list.aux_field.cint = nest[nest_ptr - 2].aux_field.cint;
1135   }
1136   else if (mode > 0)
1137 /*    long to short ... */
1138   mode = - (integer) mode;
1139   scan_spec(6, false);
1140   mem[align_head].hh.v.RH = 0;
1141   cur_align = align_head;
1142   cur_loop = 0;
1143   scanner_status = 4;
1144   warning_index = savecsptr;
1145   align_state = -1000000L;
1146   while(true){
1147     mem[cur_align].hh.v.RH = new_param_glue(11);
1148     cur_align = mem[cur_align].hh.v.RH;
1149     if (cur_cmd == 5)
1150     goto lab30;
1151     p = hold_head;
1152     mem[p].hh.v.RH = 0;
1153     while(true){
1154       get_preamble_token();
1155       if (cur_cmd == 6)
1156       goto lab31;
1157       if ((cur_cmd <= 5)&&(cur_cmd >= 4)&&(align_state == -1000000L))
1158       if ((p == hold_head)&&(cur_loop == 0)&&(cur_cmd == 4))
1159       cur_loop = cur_align;
1160       else {
1161     print_err("Missing # inserted in alignment preamble");
1162         help3("There should be exactly one # between &'s, when an",
1163                 "\\halign or \\valign is being set up. In this case you had",
1164                 "none, so I've put one in; maybe that will work.");
1165   back_error();
1166   goto lab31;
1167       }
1168       else if ((cur_cmd != 10)||(p != hold_head))
1169       {
1170   mem[p].hh.v.RH = get_avail();
1171   p = mem[p].hh.v.RH;
1172   mem[p].hh.v.LH = cur_tok;
1173       }
1174     }
1175     lab31:;
1176     mem[cur_align].hh.v.RH = new_null_box();
1177     cur_align = mem[cur_align].hh.v.RH;
1178     mem[cur_align].hh.v.LH = end_span;
1179     mem[cur_align + 1].cint = -1073741824L;  /* - 2^30 */
1180     mem[cur_align + 3].cint = mem[hold_head].hh.v.RH;
1181     p = hold_head;
1182     mem[p].hh.v.RH = 0;
1183     while(true){
1184 lab22:
1185     get_preamble_token();
1186       if ((cur_cmd <= 5)&&(cur_cmd >= 4)&&(align_state == -1000000L))
1187       goto lab32;
1188       if (cur_cmd == 6)
1189       {
1190                   print_err("Only one # is allowed per tab");
1191                   help3("There should be exactly one # between &'s, when an",
1192                           "\\halign or \\valign is being set up. In this case you had",
1193                           "more than one, so I'm ignoring all but the first.");
1194   error();
1195   goto lab22;
1196       }
1197       mem[p].hh.v.RH = get_avail();
1198       p = mem[p].hh.v.RH;
1199       mem[p].hh.v.LH = cur_tok;
1200     }
1201     lab32: mem[p].hh.v.RH = get_avail();
1202     p = mem[p].hh.v.RH;
1203 /*    mem[p].hh.v.LH = (hash_size + 4614);  */
1204 /*    mem[p].hh.v.LH = (hash_size + 4095 + 519);  */
1205     mem[p].hh.v.LH = (hash_size + hash_extra + 4095 + 519); /* 96/Jan/10 */
1206     mem[cur_align + 2].cint = mem[hold_head].hh.v.RH;
1207   }
1208   lab30: scanner_status = 0;
1209   new_save_level(6);
1210 /* if every_cr<>null then begin_token_list(every_cr,every_cr_text); l.15665 */
1211   if (every_cr != 0)/* everycr */
1212     begin_token_list(every_cr, 13);
1213   align_peek();
1214 }
1215 void init_span_ (halfword p)
1216 {
1217   push_nest();
1218   if (mode == -102)
1219   space_factor = 1000;
1220   else {
1221
1222     cur_list.aux_field.cint = ignore_depth;
1223     normal_paragraph();
1224   }
1225   cur_span = p;
1226 }
1227 void init_row (void)
1228 {
1229   push_nest();
1230   mode =(-103)- mode;
1231   if (mode == -102)
1232   space_factor = 0;
1233   else cur_list.aux_field.cint = 0;
1234   {
1235     mem[tail].hh.v.RH = new_glue(mem[mem[align_head]
1236    .hh.v.RH + 1].hh.v.LH);
1237     tail = mem[tail].hh.v.RH;
1238   }
1239   mem[tail].hh.b1 = 12;
1240   cur_align = mem[mem[align_head].hh.v.RH].hh.v.RH;
1241   cur_tail = cur_head;
1242   init_span(cur_align);
1243 }
1244 void init_col (void)
1245 {
1246   mem[cur_align + 5].hh.v.LH = cur_cmd;
1247   if (cur_cmd == 63)
1248   align_state = 0;
1249   else {
1250
1251     back_input();
1252     begin_token_list(mem[cur_align + 3].cint, 1);
1253   }
1254 }
1255 /* fin_col() moved to end to hide in pragma (g, "off") */
1256 /* may need to move more ? everything calling new_null_box() ? */
1257 void fin_row (void)
1258 {
1259   halfword p;
1260   if (mode == -102)
1261   {
1262     p = hpack(mem[head].hh.v.RH, 0, 1);
1263     pop_nest();
1264     append_to_vlist(p);
1265     if (cur_head != cur_tail)
1266     {
1267       mem[tail].hh.v.RH = mem[cur_head].hh.v.RH;
1268       tail = cur_tail;
1269     }
1270   }
1271   else {
1272
1273     p = vpackage(mem[head].hh.v.RH, 0, 1,
1274     1073741823L);   /* 2^30 - 1 */
1275     pop_nest();
1276     mem[tail].hh.v.RH = p;
1277     tail = p;
1278     space_factor = 1000;
1279   }
1280   mem[p].hh.b0 = 13;
1281   mem[p + 6].cint = 0;
1282   if (every_cr != 0)/* everycr */
1283     begin_token_list(every_cr, 13);
1284   align_peek();
1285 }
1286 void fin_align (void)
1287 {
1288   halfword p, q, r, s, u, v;
1289   scaled t, w;
1290   scaled o;
1291   halfword n;
1292   scaled rulesave;
1293   memory_word auxsave;
1294
1295   if (cur_group != 6){
1296     confusion("align1");
1297     return;       // abort_flag set
1298   }
1299   unsave();
1300   if (cur_group != 6){
1301     confusion("align0");
1302     return;       // abort_flag set
1303   }
1304   unsave();
1305   if (nest[nest_ptr - 1].mode_field == 203)
1306   o = display_indent;
1307   else o = 0;
1308   q = mem[mem[align_head].hh.v.RH].hh.v.RH;
1309   do {
1310       flush_list(mem[q + 3].cint);
1311     flush_list(mem[q + 2].cint);
1312     p = mem[mem[q].hh.v.RH].hh.v.RH;
1313     if (mem[q + 1].cint == -1073741824L) /* - 2^30 */
1314     {
1315       mem[q + 1].cint = 0;
1316       r = mem[q].hh.v.RH;
1317       s = mem[r + 1].hh.v.LH;
1318       if (s != 0)
1319       {
1320   incr(mem[0].hh.v.RH); /* mem[mem_bot]? mem[null]? */
1321   delete_glue_ref(s);
1322   mem[r + 1].hh.v.LH = 0;
1323       }
1324     }
1325     if (mem[q].hh.v.LH != end_span)
1326     {
1327       t = mem[q + 1].cint + mem[mem[mem[q].hh.v.RH + 1].hh
1328      .v.LH + 1].cint;
1329       r = mem[q].hh.v.LH;
1330       s = end_span;
1331       mem[s].hh.v.LH = p;
1332       n = 1;
1333       do {
1334     mem[r + 1].cint = mem[r + 1].cint - t;
1335   u = mem[r].hh.v.LH;
1336   while(mem[r].hh.v.RH > n){
1337
1338     s = mem[s].hh.v.LH;
1339     n = mem[mem[s].hh.v.LH].hh.v.RH + 1;
1340   }
1341   if (mem[r].hh.v.RH < n)
1342   {
1343     mem[r].hh.v.LH = mem[s].hh.v.LH;
1344     mem[s].hh.v.LH = r;
1345     decr(mem[r].hh.v.RH);
1346     s = r;
1347   }
1348   else {
1349
1350     if (mem[r + 1].cint > mem[mem[s].hh.v.LH + 1].cint)
1351     mem[mem[s].hh.v.LH + 1].cint = mem[r + 1].cint;
1352     free_node(r, 2);
1353   }
1354   r = u;
1355       } while(!(r == end_span));
1356     }
1357     mem[q].hh.b0 = 13;
1358     mem[q].hh.b1 = 0;
1359     mem[q + 3].cint = 0;
1360     mem[q + 2].cint = 0;
1361     mem[q + 5].hh.b1 = 0;
1362     mem[q + 5].hh.b0 = 0;
1363     mem[q + 6].cint = 0;
1364     mem[q + 4].cint = 0;
1365     q = p;
1366   } while(!(q == 0));
1367   save_ptr = save_ptr - 2;
1368   pack_begin_line = - (integer) mode_line;
1369   if (mode == -1)
1370   {
1371     rulesave = overfull_rule;
1372     overfull_rule = 0;
1373     p = hpack(mem[align_head].hh.v.RH, save_stack[save_ptr + 1].cint, save_stack[save_ptr + 0].cint);
1374     overfull_rule = rulesave;
1375   }
1376   else {
1377
1378     q = mem[mem[align_head].hh.v.RH].hh.v.RH;
1379     do {
1380   mem[q + 3].cint = mem[q + 1].cint;
1381       mem[q + 1].cint = 0;
1382       q = mem[mem[q].hh.v.RH].hh.v.RH;
1383     } while(!(q == 0));
1384     p = vpackage(mem[align_head].hh.v.RH, save_stack[save_ptr + 1]
1385    .cint, save_stack[save_ptr + 0].cint, 1073741823L);  /* 2^30 - 1 */
1386     q = mem[mem[align_head].hh.v.RH].hh.v.RH;
1387     do {
1388   mem[q + 1].cint = mem[q + 3].cint;
1389       mem[q + 3].cint = 0;
1390       q = mem[mem[q].hh.v.RH].hh.v.RH;
1391     } while(!(q == 0));
1392   }
1393   pack_begin_line = 0;
1394   q = mem[head].hh.v.RH;
1395   s = head;
1396   while(q != 0){    /* while q<>null l.15794 OK */
1397
1398     if (!(q >= hi_mem_min))  /*   begin if not is_char_node(q) then */
1399     if (mem[q].hh.b0 == 13)
1400     {
1401       if (mode == -1)
1402       {
1403   mem[q].hh.b0 = 0;
1404   mem[q + 1].cint = mem[p + 1].cint;
1405       }
1406       else {
1407
1408   mem[q].hh.b0 = 1;
1409   mem[q + 3].cint = mem[p + 3].cint;
1410       }
1411       mem[q + 5].hh.b1 = mem[p + 5].hh.b1;
1412       mem[q + 5].hh.b0 = mem[p + 5].hh.b0;
1413       mem[q + 6].gr = mem[p + 6].gr;
1414       mem[q + 4].cint = o;
1415       r = mem[mem[q + 5].hh.v.RH].hh.v.RH;
1416       s = mem[mem[p + 5].hh.v.RH].hh.v.RH;
1417       do {
1418     n = mem[r].hh.b1;
1419   t = mem[s + 1].cint;
1420   w = t;
1421   u = hold_head;
1422   while(n > 0){
1423
1424     decr(n);
1425     s = mem[s].hh.v.RH;
1426     v = mem[s + 1].hh.v.LH;
1427     mem[u].hh.v.RH = new_glue(v);
1428     u = mem[u].hh.v.RH;
1429     mem[u].hh.b1 = 12;
1430     t = t + mem[v + 1].cint;
1431     if (mem[p + 5].hh.b0 == 1)
1432     {
1433       if (mem[v].hh.b0 == mem[p + 5].hh.b1)
1434       t = t + round(mem[p + 6].gr * mem[v + 2].cint);
1435     }
1436     else if (mem[p + 5].hh.b0 == 2)
1437     {
1438       if (mem[v].hh.b1 == mem[p + 5].hh.b1)
1439       t = t - round(mem[p + 6].gr * mem[v + 3].cint);
1440     }
1441     s = mem[s].hh.v.RH;
1442     mem[u].hh.v.RH = new_null_box();
1443     u = mem[u].hh.v.RH;
1444     t = t + mem[s + 1].cint;
1445     if (mode == -1)
1446     mem[u + 1].cint = mem[s + 1].cint;
1447     else {
1448
1449       mem[u].hh.b0 = 1;
1450       mem[u + 3].cint = mem[s + 1].cint;
1451     }
1452   }
1453   if (mode == -1)
1454   {
1455     mem[r + 3].cint = mem[q + 3].cint;
1456     mem[r + 2].cint = mem[q + 2].cint;
1457     if (t == mem[r + 1].cint)
1458     {
1459       mem[r + 5].hh.b0 = 0;
1460       mem[r + 5].hh.b1 = 0;
1461       mem[r + 6].gr = 0.0;
1462     }
1463     else if (t > mem[r + 1].cint)
1464     {
1465       mem[r + 5].hh.b0 = 1;
1466       if (mem[r + 6].cint == 0)
1467       mem[r + 6].gr = 0.0;
1468       else mem[r + 6].gr =(t - mem[r + 1].cint)/ ((double)
1469       mem[r + 6].cint);
1470     }
1471     else {
1472
1473       mem[r + 5].hh.b1 = mem[r + 5].hh.b0;
1474       mem[r + 5].hh.b0 = 2;
1475       if (mem[r + 4].cint == 0)
1476       mem[r + 6].gr = 0.0;
1477       else if ((mem[r + 5].hh.b1 == 0)&&(mem[r + 1].cint -
1478       t > mem[r + 4].cint))
1479       mem[r + 6].gr = 1.0;
1480       else mem[r + 6].gr =(mem[r + 1].cint - t)/ ((double)
1481       mem[r + 4].cint);
1482     }
1483     mem[r + 1].cint = w;
1484     mem[r].hh.b0 = 0;
1485   }
1486   else {
1487
1488     mem[r + 1].cint = mem[q + 1].cint;
1489     if (t == mem[r + 3].cint)
1490     {
1491       mem[r + 5].hh.b0 = 0;
1492       mem[r + 5].hh.b1 = 0;
1493       mem[r + 6].gr = 0.0;
1494     }
1495     else if (t > mem[r + 3].cint)
1496     {
1497       mem[r + 5].hh.b0 = 1;
1498       if (mem[r + 6].cint == 0)
1499       mem[r + 6].gr = 0.0;
1500       else mem[r + 6].gr =(t - mem[r + 3].cint)/ ((double)
1501       mem[r + 6].cint);
1502     }
1503     else {
1504
1505       mem[r + 5].hh.b1 = mem[r + 5].hh.b0;
1506       mem[r + 5].hh.b0 = 2;
1507       if (mem[r + 4].cint == 0)
1508       mem[r + 6].gr = 0.0;
1509       else if ((mem[r + 5].hh.b1 == 0)&&(mem[r + 3].cint -
1510       t > mem[r + 4].cint))
1511       mem[r + 6].gr = 1.0;
1512       else mem[r + 6].gr =(mem[r + 3].cint - t)/ ((double)
1513       mem[r + 4].cint);
1514     }
1515     mem[r + 3].cint = w;
1516     mem[r].hh.b0 = 1;
1517   }
1518   mem[r + 4].cint = 0;
1519   if (u != hold_head)
1520   {
1521     mem[u].hh.v.RH = mem[r].hh.v.RH;
1522     mem[r].hh.v.RH = mem[hold_head].hh.v.RH;
1523     r = u;
1524   }
1525   r = mem[mem[r].hh.v.RH].hh.v.RH;
1526   s = mem[mem[s].hh.v.RH].hh.v.RH;
1527       } while(!(r == 0));
1528     }
1529     else if (mem[q].hh.b0 == 2)
1530     {
1531       if ((mem[q + 1].cint == -1073741824L))  /* 2^30  */
1532       mem[q + 1].cint = mem[p + 1].cint;
1533       if ((mem[q + 3].cint == -1073741824L))  /* 2^30  */
1534       mem[q + 3].cint = mem[p + 3].cint;
1535       if ((mem[q + 2].cint == -1073741824L))  /* 2^30  */
1536       mem[q + 2].cint = mem[p + 2].cint;
1537       if (o != 0)
1538       {
1539   r = mem[q].hh.v.RH;
1540   mem[q].hh.v.RH = 0;
1541   q = hpack(q, 0, 1);
1542   mem[q + 4].cint = o;
1543   mem[q].hh.v.RH = r;
1544   mem[s].hh.v.RH = q;
1545       }
1546     }
1547     s = q;
1548     q = mem[q].hh.v.RH;
1549   }
1550   flush_node_list(p);
1551   pop_alignment();
1552   auxsave = cur_list.aux_field;
1553   p = mem[head].hh.v.RH;
1554   q = tail;
1555   pop_nest();
1556   if (mode == 203)
1557   {
1558     do_assignments();
1559     if (cur_cmd != 3) {
1560                 print_err("Missing $$ inserted");
1561                 help2("Displays can use special alignments (like \\eqalignno)",
1562                         "only if nothing but the alignment itself is between $$'s.");
1563       back_error();
1564     }
1565     else {
1566
1567       get_x_token();
1568       if (cur_cmd != 3)
1569       {
1570                   print_err("Display math should end with $$");
1571                   help2("The `$' that I just saw supposedly matches a previous `$$'.",
1572                           "So I shall assume that you typed `$$' both times.");
1573   back_error();
1574       }
1575   }
1576     pop_nest();
1577     {
1578       mem[tail].hh.v.RH = new_penalty(pre_display_penalty);
1579       tail = mem[tail].hh.v.RH;
1580     }
1581     {
1582       mem[tail].hh.v.RH = new_param_glue(3);
1583       tail = mem[tail].hh.v.RH;
1584     }
1585     mem[tail].hh.v.RH = p;
1586     if (p != 0)
1587     tail = q;
1588     {
1589       mem[tail].hh.v.RH = new_penalty(post_display_penalty);
1590       tail = mem[tail].hh.v.RH;
1591     }
1592     {
1593       mem[tail].hh.v.RH = new_param_glue(4);
1594       tail = mem[tail].hh.v.RH;
1595     }
1596     cur_list.aux_field.cint = auxsave.cint;
1597     resume_after_display();
1598   }
1599   else {
1600
1601     cur_list.aux_field = auxsave;
1602     mem[tail].hh.v.RH = p;
1603     if (p != 0)    /*   if p<>null then tail:=q; l.15926 */
1604     tail = q;
1605     if (mode == 1){
1606     build_page();
1607   }
1608   }
1609 }
1610 /* used to be align_peek, zfintieshrink, etc in old tex5.c */
1611 /************************************************************************/
1612 /* moved down here to avoid questions about pragma optimize */
1613 #pragma optimize("g", off)          /* for MC VS compiler */
1614 /*  Moved down here 96/Oct/12 in response to problem with texerror.tex */
1615 /*  pragma optimize("a", off) not strong enough - this may slow things */
1616 bool fin_col (void)
1617 {/* 10 */ register bool Result;
1618   halfword p;
1619   halfword q, r;
1620   halfword s;
1621   halfword u;
1622   scaled w;
1623   glue_ord o;
1624   halfword n;
1625   if (cur_align == 0){
1626     confusion("endv");
1627     return 0;       // abort_flag set
1628   }
1629   q = mem[cur_align].hh.v.RH;
1630   if (q == 0){
1631     confusion("endv");
1632     return 0;       // abort_flag set
1633   }
1634   if (align_state < 500000L) {     /* ??? */
1635     fatal_error("(interwoven alignment preambles are not allowed)"); /*  */
1636     return 0;     // abort_flag set
1637   }
1638   p = mem[q].hh.v.RH;         /* p <- link(q) p.791 */
1639 /* if (p = null) ^ (extra_info(cur_align) < cr_code) then p.792 */
1640   if ((p == 0)&&(mem[cur_align + 5].hh.v.LH < 257))
1641   if (cur_loop != 0)
1642   {
1643 /*  potential problem here if new_null_box causes memory reallocation ??? */
1644 /*  compiler optimization does not refresh `mem' loaded in registers ? */
1645     mem[q].hh.v.RH = new_null_box();
1646     p = mem[q].hh.v.RH;
1647     mem[p].hh.v.LH = end_span;
1648     mem[p + 1].cint = -1073741824L;  /* - 2^30 */
1649     cur_loop = mem[cur_loop].hh.v.RH;
1650     q = hold_head;
1651     r = mem[cur_loop + 3].cint;
1652     while(r != 0){
1653
1654       mem[q].hh.v.RH = get_avail();
1655       q = mem[q].hh.v.RH;
1656       mem[q].hh.v.LH = mem[r].hh.v.LH;
1657       r = mem[r].hh.v.RH;
1658     }
1659     mem[q].hh.v.RH = 0;
1660     mem[p + 3].cint = mem[hold_head].hh.v.RH;
1661     q = hold_head;
1662     r = mem[cur_loop + 2].cint;
1663     while(r != 0){
1664
1665       mem[q].hh.v.RH = get_avail();
1666       q = mem[q].hh.v.RH;
1667       mem[q].hh.v.LH = mem[r].hh.v.LH;
1668       r = mem[r].hh.v.RH;
1669     }
1670     mem[q].hh.v.RH = 0;
1671     mem[p + 2].cint = mem[hold_head].hh.v.RH;
1672     cur_loop = mem[cur_loop].hh.v.RH;
1673     mem[p].hh.v.RH = new_glue(mem[cur_loop + 1].hh.v.LH);
1674   }
1675   else {
1676       print_err("Extra alignment tab has been changed to ");
1677     print_esc("cr");
1678         help3("You have given more \\span or & marks than there were",
1679                 "in the preamble to the \\halign or \\valign now in progress.",
1680                 "So I'll assume that you meant to type \\cr instead.");
1681 /* extra_info(cur_align) < cr_code) ? */
1682     mem[cur_align + 5].hh.v.LH = 257;
1683     error();
1684   }
1685   if (mem[cur_align + 5].hh.v.LH != 256)
1686   {
1687     unsave();
1688     new_save_level(6);
1689     {
1690       if (mode == -102)
1691       {
1692   adjust_tail = cur_tail;
1693   u = hpack(mem[head].hh.v.RH, 0, 1);
1694   w = mem[u + 1].cint;
1695   cur_tail = adjust_tail;
1696   adjust_tail = 0;
1697       }
1698       else {
1699
1700   u = vpackage(mem[head].hh.v.RH, 0, 1, 0);
1701   w = mem[u + 3].cint;
1702       }
1703       n = 0;
1704       if (cur_span != cur_align)
1705       {
1706   q = cur_span;
1707   do {
1708       incr(n);
1709     q = mem[mem[q].hh.v.RH].hh.v.RH;
1710   } while(!(q == cur_align));
1711 /*  if n > max_quarterword then confusion("256 spans"); p.798 */
1712 /*  if (n > 255) */            /* 94/Apr/4 ? */
1713   if (n > max_quarterword) {       /* 96/Oct/12 ??? */
1714     confusion("256 spans");   /* 256 spans --- message wrong now, but ... */
1715     return 0;       // abort_flag set
1716   }
1717   q = cur_span;
1718   while(mem[mem[q].hh.v.LH].hh.v.RH < n)q = mem[q].hh
1719   .v.LH;
1720   if (mem[mem[q].hh.v.LH].hh.v.RH > n)
1721   {
1722     s = get_node(2);
1723     mem[s].hh.v.LH = mem[q].hh.v.LH;
1724     mem[s].hh.v.RH = n;
1725     mem[q].hh.v.LH = s;
1726     mem[s + 1].cint = w;
1727   }
1728   else if (mem[mem[q].hh.v.LH + 1].cint < w)
1729   mem[mem[q].hh.v.LH + 1].cint = w;
1730       }
1731       else if (w > mem[cur_align + 1].cint)
1732       mem[cur_align + 1].cint = w;
1733       mem[u].hh.b0 = 13;
1734       mem[u].hh.b1 = n;
1735       if (total_stretch[3]!= 0)
1736       o = 3;
1737       else if (total_stretch[2]!= 0)
1738       o = 2;
1739       else if (total_stretch[1]!= 0)
1740       o = 1;
1741       else o = 0;
1742       mem[u + 5].hh.b1 = o;
1743       mem[u + 6].cint = total_stretch[o];
1744       if (total_shrink[3]!= 0)
1745       o = 3;
1746       else if (total_shrink[2]!= 0)
1747       o = 2;
1748       else if (total_shrink[1]!= 0)
1749       o = 1;
1750       else o = 0;
1751       mem[u + 5].hh.b0 = o;
1752       mem[u + 4].cint = total_shrink[o];
1753       pop_nest();
1754       mem[tail].hh.v.RH = u;
1755       tail = u;
1756     }
1757     {
1758       mem[tail].hh.v.RH = new_glue(mem[mem[cur_align]
1759      .hh.v.RH + 1].hh.v.LH);
1760       tail = mem[tail].hh.v.RH;
1761     }
1762     mem[tail].hh.b1 = 12;
1763 /* if (extra_info(cur_align) >= cr_code) then p.792 */
1764     if (mem[cur_align + 5].hh.v.LH >= 257)
1765     {
1766       Result = true;
1767       return(Result);
1768     }
1769     init_span(p);
1770   }
1771   align_state = 1000000L;
1772   do {
1773       get_x_token();
1774   } while(!(cur_cmd != 10));
1775   cur_align = p;
1776   init_col();
1777   Result = false;
1778   return Result;
1779 }
1780 /* #pragma optimize ("g", on) */        /* for MC VS compiler */
1781 /* #pragma optimize ("g",) */         /* 94/Jan/25 */
1782 /* #pragma optimize ("", on) */           /* 96/Sep/12 */
1783 /* #pragma optimize("g", off) */          /* for MC VS compiler */
1784
1785 scaled make_op_(halfword q)
1786 {register scaled Result;
1787   scaled delta;
1788   halfword p, v, x, y, z;
1789   quarterword c;
1790   ffourquarters i;
1791   scaled shiftup, shiftdown;
1792   if ((mem[q].hh.b1 == 0)&&(cur_style < 2))
1793   mem[q].hh.b1 = 1;
1794   if (mem[q + 1].hh.v.RH == 1)
1795   {
1796     fetch(q + 1);
1797     if ((cur_style < 2)&&(((cur_i.b2)% 4)== 2))
1798     {
1799       c = cur_i.b3;
1800       i = font_info[char_base[cur_f]+ c].qqqq;
1801       if ((i.b0 > 0))
1802       {
1803   cur_c = c;
1804   cur_i = i;
1805   mem[q + 1].hh.b1 = c;
1806       }
1807     }
1808     delta = font_info[italic_base[cur_f]+(cur_i.b2)/ 4].cint;
1809     x = clean_box(q + 1, cur_style);
1810     if ((mem[q + 3].hh.v.RH != 0)&&(mem[q].hh.b1 != 1))
1811     mem[x + 1].cint = mem[x + 1].cint - delta;
1812     mem[x + 4].cint = half(mem[x + 3].cint - mem[x + 2].cint)-
1813     font_info[22 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint;
1814     mem[q + 1].hh.v.RH = 2;
1815     mem[q + 1].hh.v.LH = x;
1816   }
1817   else delta = 0;
1818   if (mem[q].hh.b1 == 1)
1819   {
1820     x = clean_box(q + 2, 2 *(cur_style / 4)+ 4 +(cur_style % 2));
1821     y = clean_box(q + 1, cur_style);
1822     z = clean_box(q + 3, 2 *(cur_style / 4)+ 5);
1823     v = new_null_box();
1824     mem[v].hh.b0 = 1;
1825     mem[v + 1].cint = mem[y + 1].cint;
1826     if (mem[x + 1].cint > mem[v + 1].cint)
1827     mem[v + 1].cint = mem[x + 1].cint;
1828     if (mem[z + 1].cint > mem[v + 1].cint)
1829     mem[v + 1].cint = mem[z + 1].cint;
1830     x = rebox(x, mem[v + 1].cint);
1831     y = rebox(y, mem[v + 1].cint);
1832     z = rebox(z, mem[v + 1].cint);
1833     mem[x + 4].cint = half(delta);
1834     mem[z + 4].cint = - (integer) mem[x + 4].cint;
1835     mem[v + 3].cint = mem[y + 3].cint;
1836     mem[v + 2].cint = mem[y + 2].cint;
1837     if (mem[q + 2].hh.v.RH == 0)
1838     {
1839       free_node(x, 7);
1840       mem[v + 5].hh.v.RH = y;
1841     }
1842     else {
1843
1844       shiftup = font_info[11 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH
1845     ]].cint - mem[x + 2].cint;
1846       if (shiftup < font_info[9 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1847      .v.RH]].cint)
1848       shiftup = font_info[9 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH
1849     ]].cint;
1850       p = new_kern(shiftup);
1851       mem[p].hh.v.RH = y;
1852       mem[x].hh.v.RH = p;
1853       p = new_kern(font_info[13 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1854      .v.RH]].cint);
1855       mem[p].hh.v.RH = x;
1856       mem[v + 5].hh.v.RH = p;
1857       mem[v + 3].cint = mem[v + 3].cint + font_info[13 + param_base[
1858       eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint + mem[x + 3].cint + mem
1859      [x + 2].cint + shiftup;
1860     }
1861     if (mem[q + 3].hh.v.RH == 0)
1862     free_node(z, 7);
1863     else {
1864
1865       shiftdown = font_info[12 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1866      .v.RH]].cint - mem[z + 3].cint;
1867       if (shiftdown < font_info[10 + param_base[eqtb[(hash_size + 1838) + cur_size]
1868      .hh.v.RH]].cint)
1869       shiftdown = font_info[10 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1870      .v.RH]].cint;
1871       p = new_kern(shiftdown);
1872       mem[y].hh.v.RH = p;
1873       mem[p].hh.v.RH = z;
1874       p = new_kern(font_info[13 + param_base[eqtb[(hash_size + 1838) + cur_size].hh
1875      .v.RH]].cint);
1876       mem[z].hh.v.RH = p;
1877       mem[v + 2].cint = mem[v + 2].cint + font_info[13 + param_base[
1878       eqtb[(hash_size + 1838) + cur_size].hh.v.RH]].cint + mem[z + 3].cint + mem
1879      [z + 2].cint + shiftdown;
1880     }
1881     mem[q + 1].cint = v;
1882   }
1883   Result = delta;
1884   return Result;
1885 }
1886 /* #pragma optimize ("g", on) */        /* for MC VS compiler */
1887 /* #pragma optimize ("g",) */         /* 94/Jan/25 */
1888 /* #pragma optimize ("", on) */           /* 96/Sep/12 */
1889 /* #pragma optimize ("g", off) */
1890
1891 void make_scripts_(halfword q, scaled delta)
1892 {
1893   halfword p, x, y, z;
1894   scaled shiftup, shiftdown, clr;
1895   small_number t;
1896   p = mem[q + 1].cint;
1897   if ((p >= hi_mem_min))
1898   {
1899     shiftup = 0;
1900     shiftdown = 0;
1901   }
1902   else {
1903
1904     z = hpack(p, 0, 1);
1905     if (cur_style < 4)
1906     t = 16;
1907     else t = 32;
1908     shiftup = mem[z + 3].cint - font_info[18 + param_base[eqtb[(hash_size + 1837) +
1909     t].hh.v.RH]].cint;
1910     shiftdown = mem[z + 2].cint + font_info[19 + param_base[eqtb[(hash_size + 1837)
1911     + t].hh.v.RH]].cint;
1912     free_node(z, 7);
1913   }
1914   if (mem[q + 2].hh.v.RH == 0)
1915   {
1916     x = clean_box(q + 3, 2 *(cur_style / 4)+ 5);
1917     mem[x + 1].cint = mem[x + 1].cint + script_space;
1918     if (shiftdown < font_info[16 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1919    .v.RH]].cint)
1920     shiftdown = font_info[16 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH
1921   ]].cint;
1922     clr = mem[x + 3].cint -(abs(font_info[5 + param_base[eqtb[
1923     (hash_size + 1837) + cur_size].hh.v.RH]].cint * 4)/ 5);
1924     if (shiftdown < clr)
1925     shiftdown = clr;
1926     mem[x + 4].cint = shiftdown;
1927   }
1928   else {
1929
1930     {
1931       x = clean_box(q + 2, 2 *(cur_style / 4)+ 4 +(cur_style % 2));
1932       mem[x + 1].cint = mem[x + 1].cint + script_space;
1933       if (odd(cur_style))
1934       clr = font_info[15 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]]
1935      .cint;
1936       else if (cur_style < 2)
1937       clr = font_info[13 + param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]]
1938      .cint;
1939       else clr = font_info[14 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1940      .v.RH]].cint;
1941       if (shiftup < clr)
1942       shiftup = clr;
1943       clr = mem[x + 2].cint +(abs(font_info[5 +
1944     param_base[eqtb[(hash_size + 1837) + cur_size].hh.v.RH]].cint)/ 4);
1945       if (shiftup < clr)
1946       shiftup = clr;
1947     }
1948     if (mem[q + 3].hh.v.RH == 0)
1949     mem[x + 4].cint = - (integer) shiftup;
1950     else {
1951       y = clean_box(q + 3, 2 *(cur_style / 4)+ 5);
1952       mem[y + 1].cint = mem[y + 1].cint + script_space;
1953       if (shiftdown < font_info[17 + param_base[eqtb[(hash_size + 1837) + cur_size]
1954      .hh.v.RH]].cint)
1955       shiftdown = font_info[17 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1956      .v.RH]].cint;
1957       clr = 4 * font_info[8 + param_base[eqtb[(hash_size + 1838) + cur_size].hh.v.RH
1958     ]].cint -((shiftup - mem[x + 2].cint)-(mem[y + 3].cint
1959       - shiftdown));
1960       if (clr > 0)
1961       {
1962   shiftdown = shiftdown + clr;
1963   clr =(abs(font_info[5 + param_base[eqtb[(hash_size + 1837) + cur_size].hh
1964   .v.RH]].cint * 4)/ 5)-(shiftup - mem[x + 2].cint);
1965   if (clr > 0)
1966   {
1967     shiftup = shiftup + clr;
1968     shiftdown = shiftdown - clr;
1969   }
1970       }
1971       mem[x + 4].cint = delta;
1972       p = new_kern((shiftup - mem[x + 2].cint)-(mem[y + 3].cint
1973       - shiftdown));
1974       mem[x].hh.v.RH = p;
1975       mem[p].hh.v.RH = y;
1976       x = vpackage(x, 0, 1, 1073741823L);  /* 2^30 - 1 */
1977       mem[x + 4].cint = shiftdown;
1978     }
1979   }
1980   if (mem[q + 1].cint == 0)
1981   mem[q + 1].cint = x;
1982   else {
1983
1984     p = mem[q + 1].cint;
1985     while(mem[p].hh.v.RH != 0)p = mem[p].hh.v.RH;
1986     mem[p].hh.v.RH = x;
1987   }
1988 }
1989 /* #pragma optimize ("g", on) */        /* 96/Sep/12 */
1990 /* #pragma optimize ("g") */          /* 94/Jan/25 */
1991 #pragma optimize ("", on)           /* 96/Sep/12 */
1992 /***************************************************************************/