#define EXTERN extern
#include "mpd.h"

scaled zmexp ( x ) 
scaled x ; 
{register scaled Result; smallnumber k  ; 
  integer y, z  ; 
  if ( x > 174436200L ) 
  {
    aritherror = true ; 
    Result = 2147483647L ; 
  } 
  else if ( x < -197694359L ) 
  Result = 0 ; 
  else {
      
    if ( x <= 0 ) 
    {
      z = -8 * x ; 
      y = 1048576L ; 
    } 
    else {
	
      if ( x <= 127919879L ) 
      z = 1023359037L - 8 * x ; 
      else z = 8 * ( 174436200L - x ) ; 
      y = 2147483647L ; 
    } 
    k = 1 ; 
    while ( z > 0 ) {
	
      while ( z >= speclog [ k ] ) {
	  
	z = z - speclog [ k ] ; 
	y = y - 1 - ( ( y - twotothe [ k - 1 ] ) / twotothe [ k ] ) ; 
      } 
      incr ( k ) ; 
    } 
    if ( x <= 127919879L ) 
    Result = ( y + 8 ) / 16 ; 
    else Result = y ; 
  } 
  return(Result) ; 
} 
angle znarg ( x , y ) 
integer x ; 
integer y ; 
{register angle Result; angle z  ; 
  integer t  ; 
  smallnumber k  ; 
  char octant  ; 
  if ( x >= 0 ) 
  octant = 1 ; 
  else {
      
    x = - (integer) x ; 
    octant = 2 ; 
  } 
  if ( y < 0 ) 
  {
    y = - (integer) y ; 
    octant = octant + 2 ; 
  } 
  if ( x < y ) 
  {
    t = y ; 
    y = x ; 
    x = t ; 
    octant = octant + 4 ; 
  } 
  if ( x == 0 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 314 ) ; 
    } 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 315 ; 
      helpline [ 0 ] = 309 ; 
    } 
    error () ; 
    Result = 0 ; 
  } 
  else {
      
    while ( x >= 536870912L ) {
	
      x = halfp ( x ) ; 
      y = halfp ( y ) ; 
    } 
    z = 0 ; 
    if ( y > 0 ) 
    {
      while ( x < 268435456L ) {
	  
	x = x + x ; 
	y = y + y ; 
      } 
      k = 0 ; 
      do {
	  y = y + y ; 
	incr ( k ) ; 
	if ( y > x ) 
	{
	  z = z + specatan [ k ] ; 
	  t = x ; 
	  x = x + ( y / twotothe [ k + k ] ) ; 
	  y = y - t ; 
	} 
      } while ( ! ( k == 15 ) ) ; 
      do {
	  y = y + y ; 
	incr ( k ) ; 
	if ( y > x ) 
	{
	  z = z + specatan [ k ] ; 
	  y = y - x ; 
	} 
      } while ( ! ( k == 26 ) ) ; 
    } 
    switch ( octant ) 
    {case 1 : 
      Result = z ; 
      break ; 
    case 5 : 
      Result = 94371840L - z ; 
      break ; 
    case 6 : 
      Result = 94371840L + z ; 
      break ; 
    case 2 : 
      Result = 188743680L - z ; 
      break ; 
    case 4 : 
      Result = z - 188743680L ; 
      break ; 
    case 8 : 
      Result = - (integer) z - 94371840L ; 
      break ; 
    case 7 : 
      Result = z - 94371840L ; 
      break ; 
    case 3 : 
      Result = - (integer) z ; 
      break ; 
    } 
  } 
  return(Result) ; 
} 
void znsincos ( z ) 
angle z ; 
{smallnumber k  ; 
  char q  ; 
  fraction r  ; 
  integer x, y, t  ; 
  while ( z < 0 ) z = z + 377487360L ; 
  z = z % 377487360L ; 
  q = z / 47185920L ; 
  z = z % 47185920L ; 
  x = 268435456L ; 
  y = x ; 
  if ( ! odd ( q ) ) 
  z = 47185920L - z ; 
  k = 1 ; 
  while ( z > 0 ) {
      
    if ( z >= specatan [ k ] ) 
    {
      z = z - specatan [ k ] ; 
      t = x ; 
      x = t + y / twotothe [ k ] ; 
      y = y - t / twotothe [ k ] ; 
    } 
    incr ( k ) ; 
  } 
  if ( y < 0 ) 
  y = 0 ; 
  switch ( q ) 
  {case 0 : 
    ; 
    break ; 
  case 1 : 
    {
      t = x ; 
      x = y ; 
      y = t ; 
    } 
    break ; 
  case 2 : 
    {
      t = x ; 
      x = - (integer) y ; 
      y = t ; 
    } 
    break ; 
  case 3 : 
    x = - (integer) x ; 
    break ; 
  case 4 : 
    {
      x = - (integer) x ; 
      y = - (integer) y ; 
    } 
    break ; 
  case 5 : 
    {
      t = x ; 
      x = - (integer) y ; 
      y = - (integer) t ; 
    } 
    break ; 
  case 6 : 
    {
      t = x ; 
      x = y ; 
      y = - (integer) t ; 
    } 
    break ; 
  case 7 : 
    y = - (integer) y ; 
    break ; 
  } 
  r = pythadd ( x , y ) ; 
  ncos = makefraction ( x , r ) ; 
  nsin = makefraction ( y , r ) ; 
} 
void newrandoms ( ) 
{char k  ; 
  fraction x  ; 
  {register integer for_end; k = 0 ; for_end = 23 ; if ( k <= for_end) do 
    {
      x = randoms [ k ] - randoms [ k + 31 ] ; 
      if ( x < 0 ) 
      x = x + 268435456L ; 
      randoms [ k ] = x ; 
    } 
  while ( k++ < for_end ) ; } 
  {register integer for_end; k = 24 ; for_end = 54 ; if ( k <= for_end) do 
    {
      x = randoms [ k ] - randoms [ k - 24 ] ; 
      if ( x < 0 ) 
      x = x + 268435456L ; 
      randoms [ k ] = x ; 
    } 
  while ( k++ < for_end ) ; } 
  jrandom = 54 ; 
} 
void zinitrandoms ( seed ) 
scaled seed ; 
{fraction j, jj, k  ; 
  char i  ; 
  j = abs ( seed ) ; 
  while ( j >= 268435456L ) j = halfp ( j ) ; 
  k = 1 ; 
  {register integer for_end; i = 0 ; for_end = 54 ; if ( i <= for_end) do 
    {
      jj = k ; 
      k = j - k ; 
      j = jj ; 
      if ( k < 0 ) 
      k = k + 268435456L ; 
      randoms [ ( i * 21 ) % 55 ] = j ; 
    } 
  while ( i++ < for_end ) ; } 
  newrandoms () ; 
  newrandoms () ; 
  newrandoms () ; 
} 
scaled zunifrand ( x ) 
scaled x ; 
{register scaled Result; scaled y  ; 
  if ( jrandom == 0 ) 
  newrandoms () ; 
  else decr ( jrandom ) ; 
  y = takefraction ( abs ( x ) , randoms [ jrandom ] ) ; 
  if ( y == abs ( x ) ) 
  Result = 0 ; 
  else if ( x > 0 ) 
  Result = y ; 
  else Result = - (integer) y ; 
  return(Result) ; 
} 
scaled normrand ( ) 
{register scaled Result; integer x, u, l  ; 
  do {
      do { if ( jrandom == 0 ) 
      newrandoms () ; 
      else decr ( jrandom ) ; 
      x = takefraction ( 112429L , randoms [ jrandom ] - 134217728L ) ; 
      if ( jrandom == 0 ) 
      newrandoms () ; 
      else decr ( jrandom ) ; 
      u = randoms [ jrandom ] ; 
    } while ( ! ( abs ( x ) < u ) ) ; 
    x = makefraction ( x , u ) ; 
    l = 139548960L - mlog ( u ) ; 
  } while ( ! ( abvscd ( 1024 , l , x , x ) >= 0 ) ) ; 
  Result = x ; 
  return(Result) ; 
} 
#ifdef DEBUG
void zprintword ( w ) 
memoryword w ; 
{printint ( w .cint ) ; 
  printchar ( 32 ) ; 
  printscaled ( w .cint ) ; 
  printchar ( 32 ) ; 
  printscaled ( w .cint / 4096 ) ; 
  println () ; 
  printint ( w .hhfield .lhfield ) ; 
  printchar ( 61 ) ; 
  printint ( w .hhfield .b0 ) ; 
  printchar ( 58 ) ; 
  printint ( w .hhfield .b1 ) ; 
  printchar ( 59 ) ; 
  printint ( w .hhfield .v.RH ) ; 
  printchar ( 32 ) ; 
  printint ( w .qqqq .b0 ) ; 
  printchar ( 58 ) ; 
  printint ( w .qqqq .b1 ) ; 
  printchar ( 58 ) ; 
  printint ( w .qqqq .b2 ) ; 
  printchar ( 58 ) ; 
  printint ( w .qqqq .b3 ) ; 
} 
#endif /* DEBUG */
void zshowtokenlist ( p , q , l , nulltally ) 
integer p ; 
integer q ; 
integer l ; 
integer nulltally ; 
{/* 10 */ smallnumber class, c  ; 
  integer r, v  ; 
  class = 3 ; 
  tally = nulltally ; 
  while ( ( p != 0 ) && ( tally < l ) ) {
      
    if ( p == q ) 
    {
      firstcount = tally ; 
      trickcount = tally + 1 + errorline - halferrorline ; 
      if ( trickcount < errorline ) 
      trickcount = errorline ; 
    } 
    c = 9 ; 
    if ( ( p < 0 ) || ( p > memend ) ) 
    {
      print ( 505 ) ; 
      goto lab10 ; 
    } 
    if ( p < himemmin ) 
    if ( mem [ p ] .hhfield .b1 == 15 ) 
    if ( mem [ p ] .hhfield .b0 == 16 ) 
    {
      if ( class == 0 ) 
      printchar ( 32 ) ; 
      v = mem [ p + 1 ] .cint ; 
      if ( v < 0 ) 
      {
	if ( class == 17 ) 
	printchar ( 32 ) ; 
	printchar ( 91 ) ; 
	printscaled ( v ) ; 
	printchar ( 93 ) ; 
	c = 18 ; 
      } 
      else {
	  
	printscaled ( v ) ; 
	c = 0 ; 
      } 
    } 
    else if ( mem [ p ] .hhfield .b0 != 4 ) 
    print ( 508 ) ; 
    else {
	
      printchar ( 34 ) ; 
      slowprint ( mem [ p + 1 ] .cint ) ; 
      printchar ( 34 ) ; 
      c = 4 ; 
    } 
    else if ( ( mem [ p ] .hhfield .b1 != 14 ) || ( mem [ p ] .hhfield .b0 < 1 
    ) || ( mem [ p ] .hhfield .b0 > 19 ) ) 
    print ( 508 ) ; 
    else {
	
      gpointer = p ; 
      printcapsule () ; 
      c = 8 ; 
    } 
    else {
	
      r = mem [ p ] .hhfield .lhfield ; 
      if ( r >= 2372 ) 
      {
	if ( r < 2522 ) 
	{
	  print ( 510 ) ; 
	  r = r - ( 2372 ) ; 
	} 
	else if ( r < 2672 ) 
	{
	  print ( 511 ) ; 
	  r = r - ( 2522 ) ; 
	} 
	else {
	    
	  print ( 512 ) ; 
	  r = r - ( 2672 ) ; 
	} 
	printint ( r ) ; 
	printchar ( 41 ) ; 
	c = 8 ; 
      } 
      else if ( r < 1 ) 
      if ( r == 0 ) 
      {
	if ( class == 17 ) 
	printchar ( 32 ) ; 
	print ( 509 ) ; 
	c = 18 ; 
      } 
      else print ( 506 ) ; 
      else {
	  
	r = hash [ r ] .v.RH ; 
	if ( ( r < 0 ) || ( r >= maxstrptr ) ) 
	print ( 507 ) ; 
	else {
	    
	  c = charclass [ strpool [ strstart [ r ] ] ] ; 
	  if ( c == class ) 
	  switch ( c ) 
	  {case 9 : 
	    printchar ( 46 ) ; 
	    break ; 
	  case 5 : 
	  case 6 : 
	  case 7 : 
	  case 8 : 
	    ; 
	    break ; 
	    default: 
	    printchar ( 32 ) ; 
	    break ; 
	  } 
	  print ( r ) ; 
	} 
      } 
    } 
    class = c ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  if ( p != 0 ) 
  print ( 504 ) ; 
  lab10: ; 
} 
void runaway ( ) 
{if ( scannerstatus > 2 ) 
  {
    printnl ( 659 ) ; 
    switch ( scannerstatus ) 
    {case 3 : 
      print ( 660 ) ; 
      break ; 
    case 4 : 
    case 5 : 
      print ( 661 ) ; 
      break ; 
    case 6 : 
      print ( 662 ) ; 
      break ; 
    } 
    println () ; 
    showtokenlist ( mem [ memtop - 2 ] .hhfield .v.RH , 0 , errorline - 10 , 0 
    ) ; 
  } 
} 
halfword getavail ( ) 
{register halfword Result; halfword p  ; 
  p = avail ; 
  if ( p != 0 ) 
  avail = mem [ avail ] .hhfield .v.RH ; 
  else if ( memend < memmax ) 
  {
    incr ( memend ) ; 
    p = memend ; 
  } 
  else {
      
    decr ( himemmin ) ; 
    p = himemmin ; 
    if ( himemmin <= lomemmax ) 
    {
      runaway () ; 
      overflow ( 316 , memmax + 1 ) ; 
    } 
  } 
  mem [ p ] .hhfield .v.RH = 0 ; 
	;
#ifdef STAT
  incr ( dynused ) ; 
#endif /* STAT */
  Result = p ; 
  return(Result) ; 
} 
halfword zgetnode ( s ) 
integer s ; 
{/* 40 10 20 */ register halfword Result; halfword p  ; 
  halfword q  ; 
  integer r  ; 
  integer t, tt  ; 
  lab20: p = rover ; 
  do {
      q = p + mem [ p ] .hhfield .lhfield ; 
    while ( ( mem [ q ] .hhfield .v.RH == 65535L ) ) {
	
      t = mem [ q + 1 ] .hhfield .v.RH ; 
      tt = mem [ q + 1 ] .hhfield .lhfield ; 
      if ( q == rover ) 
      rover = t ; 
      mem [ t + 1 ] .hhfield .lhfield = tt ; 
      mem [ tt + 1 ] .hhfield .v.RH = t ; 
      q = q + mem [ q ] .hhfield .lhfield ; 
    } 
    r = q - s ; 
    if ( r > toint ( p + 1 ) ) 
    {
      mem [ p ] .hhfield .lhfield = r - p ; 
      rover = p ; 
      goto lab40 ; 
    } 
    if ( r == p ) 
    if ( mem [ p + 1 ] .hhfield .v.RH != p ) 
    {
      rover = mem [ p + 1 ] .hhfield .v.RH ; 
      t = mem [ p + 1 ] .hhfield .lhfield ; 
      mem [ rover + 1 ] .hhfield .lhfield = t ; 
      mem [ t + 1 ] .hhfield .v.RH = rover ; 
      goto lab40 ; 
    } 
    mem [ p ] .hhfield .lhfield = q - p ; 
    p = mem [ p + 1 ] .hhfield .v.RH ; 
  } while ( ! ( p == rover ) ) ; 
  if ( s == 1073741824L ) 
  {
    Result = 65535L ; 
    goto lab10 ; 
  } 
  if ( lomemmax + 2 < himemmin ) 
  if ( lomemmax + 2 <= 65535L ) 
  {
    if ( himemmin - lomemmax >= 1998 ) 
    t = lomemmax + 1000 ; 
    else t = lomemmax + 1 + ( himemmin - lomemmax ) / 2 ; 
    if ( t > 65535L ) 
    t = 65535L ; 
    p = mem [ rover + 1 ] .hhfield .lhfield ; 
    q = lomemmax ; 
    mem [ p + 1 ] .hhfield .v.RH = q ; 
    mem [ rover + 1 ] .hhfield .lhfield = q ; 
    mem [ q + 1 ] .hhfield .v.RH = rover ; 
    mem [ q + 1 ] .hhfield .lhfield = p ; 
    mem [ q ] .hhfield .v.RH = 65535L ; 
    mem [ q ] .hhfield .lhfield = t - lomemmax ; 
    lomemmax = t ; 
    mem [ lomemmax ] .hhfield .v.RH = 0 ; 
    mem [ lomemmax ] .hhfield .lhfield = 0 ; 
    rover = q ; 
    goto lab20 ; 
  } 
  overflow ( 316 , memmax + 1 ) ; 
  lab40: mem [ r ] .hhfield .v.RH = 0 ; 
	;
#ifdef STAT
  varused = varused + s ; 
#endif /* STAT */
  Result = r ; 
  lab10: ; 
  return(Result) ; 
} 
void zfreenode ( p , s ) 
halfword p ; 
halfword s ; 
{halfword q  ; 
  mem [ p ] .hhfield .lhfield = s ; 
  mem [ p ] .hhfield .v.RH = 65535L ; 
  q = mem [ rover + 1 ] .hhfield .lhfield ; 
  mem [ p + 1 ] .hhfield .lhfield = q ; 
  mem [ p + 1 ] .hhfield .v.RH = rover ; 
  mem [ rover + 1 ] .hhfield .lhfield = p ; 
  mem [ q + 1 ] .hhfield .v.RH = p ; 
	;
#ifdef STAT
  varused = varused - s ; 
#endif /* STAT */
} 
void zflushlist ( p ) 
halfword p ; 
{/* 30 */ halfword q, r  ; 
  if ( p >= himemmin ) 
  if ( p != memtop ) 
  {
    r = p ; 
    do {
	q = r ; 
      r = mem [ r ] .hhfield .v.RH ; 
	;
#ifdef STAT
      decr ( dynused ) ; 
#endif /* STAT */
      if ( r < himemmin ) 
      goto lab30 ; 
    } while ( ! ( r == memtop ) ) ; 
    lab30: mem [ q ] .hhfield .v.RH = avail ; 
    avail = p ; 
  } 
} 
void zflushnodelist ( p ) 
halfword p ; 
{halfword q  ; 
  while ( p != 0 ) {
      
    q = p ; 
    p = mem [ p ] .hhfield .v.RH ; 
    if ( q < himemmin ) 
    freenode ( q , 2 ) ; 
    else {
	
      mem [ q ] .hhfield .v.RH = avail ; 
      avail = q ; 
	;
#ifdef STAT
      decr ( dynused ) ; 
#endif /* STAT */
    } 
  } 
} 
#ifdef DEBUG
void zcheckmem ( printlocs ) 
boolean printlocs ; 
{/* 31 32 33 */ halfword p, q, r  ; 
  boolean clobbered  ; 
  {register integer for_end; p = 0 ; for_end = lomemmax ; if ( p <= for_end) 
  do 
    freearr [ p ] = false ; 
  while ( p++ < for_end ) ; } 
  {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  for_end) do 
    freearr [ p ] = false ; 
  while ( p++ < for_end ) ; } 
  p = avail ; 
  q = 0 ; 
  clobbered = false ; 
  while ( p != 0 ) {
      
    if ( ( p > memend ) || ( p < himemmin ) ) 
    clobbered = true ; 
    else if ( freearr [ p ] ) 
    clobbered = true ; 
    if ( clobbered ) 
    {
      printnl ( 317 ) ; 
      printint ( q ) ; 
      goto lab31 ; 
    } 
    freearr [ p ] = true ; 
    q = p ; 
    p = mem [ q ] .hhfield .v.RH ; 
  } 
  lab31: ; 
  p = rover ; 
  q = 0 ; 
  clobbered = false ; 
  do {
      if ( ( p >= lomemmax ) ) 
    clobbered = true ; 
    else if ( ( mem [ p + 1 ] .hhfield .v.RH >= lomemmax ) ) 
    clobbered = true ; 
    else if ( ! ( ( mem [ p ] .hhfield .v.RH == 65535L ) ) || ( mem [ p ] .hhfield .lhfield < 2 ) || ( p + mem [ p ] .hhfield .lhfield > lomemmax ) 
    || ( mem [ mem [ p + 1 ] .hhfield .v.RH + 1 ] .hhfield .lhfield != p ) ) 
    clobbered = true ; 
    if ( clobbered ) 
    {
      printnl ( 318 ) ; 
      printint ( q ) ; 
      goto lab32 ; 
    } 
    {register integer for_end; q = p ; for_end = p + mem [ p ] .hhfield .lhfield - 1 ; if ( q <= for_end) do 
      {
	if ( freearr [ q ] ) 
	{
	  printnl ( 319 ) ; 
	  printint ( q ) ; 
	  goto lab32 ; 
	} 
	freearr [ q ] = true ; 
      } 
    while ( q++ < for_end ) ; } 
    q = p ; 
    p = mem [ p + 1 ] .hhfield .v.RH ; 
  } while ( ! ( p == rover ) ) ; 
  lab32: ; 
  p = 0 ; 
  while ( p <= lomemmax ) {
      
    if ( ( mem [ p ] .hhfield .v.RH == 65535L ) ) 
    {
      printnl ( 320 ) ; 
      printint ( p ) ; 
    } 
    while ( ( p <= lomemmax ) && ! freearr [ p ] ) incr ( p ) ; 
    while ( ( p <= lomemmax ) && freearr [ p ] ) incr ( p ) ; 
  } 
  q = 5 ; 
  p = mem [ q ] .hhfield .v.RH ; 
  while ( p != 5 ) {
      
    if ( mem [ p + 1 ] .hhfield .lhfield != q ) 
    {
      printnl ( 609 ) ; 
      printint ( p ) ; 
    } 
    p = mem [ p + 1 ] .hhfield .v.RH ; 
    while ( true ) {
	
      r = mem [ p ] .hhfield .lhfield ; 
      q = p ; 
      p = mem [ q ] .hhfield .v.RH ; 
      if ( r == 0 ) 
      goto lab33 ; 
      if ( mem [ mem [ p ] .hhfield .lhfield + 1 ] .cint >= mem [ r + 1 ] .cint ) 
      {
	printnl ( 610 ) ; 
	printint ( p ) ; 
      } 
    } 
    lab33: ; 
  } 
  if ( printlocs ) 
  {
    q = memmax ; 
    r = memmax ; 
    printnl ( 321 ) ; 
    {register integer for_end; p = 0 ; for_end = lomemmax ; if ( p <= 
    for_end) do 
      if ( ! freearr [ p ] && ( ( p > waslomax ) || wasfree [ p ] ) ) 
      {
	if ( p > q + 1 ) 
	{
	  if ( q > r ) 
	  {
	    print ( 322 ) ; 
	    printint ( q ) ; 
	  } 
	  printchar ( 32 ) ; 
	  printint ( p ) ; 
	  r = p ; 
	} 
	q = p ; 
      } 
    while ( p++ < for_end ) ; } 
    {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
    for_end) do 
      if ( ! freearr [ p ] && ( ( p < washimin ) || ( p > wasmemend ) || 
      wasfree [ p ] ) ) 
      {
	if ( p > q + 1 ) 
	{
	  if ( q > r ) 
	  {
	    print ( 322 ) ; 
	    printint ( q ) ; 
	  } 
	  printchar ( 32 ) ; 
	  printint ( p ) ; 
	  r = p ; 
	} 
	q = p ; 
      } 
    while ( p++ < for_end ) ; } 
    if ( q > r ) 
    {
      print ( 322 ) ; 
      printint ( q ) ; 
    } 
  } 
  {register integer for_end; p = 0 ; for_end = lomemmax ; if ( p <= for_end) 
  do 
    wasfree [ p ] = freearr [ p ] ; 
  while ( p++ < for_end ) ; } 
  {register integer for_end; p = himemmin ; for_end = memend ; if ( p <= 
  for_end) do 
    wasfree [ p ] = freearr [ p ] ; 
  while ( p++ < for_end ) ; } 
  wasmemend = memend ; 
  waslomax = lomemmax ; 
  washimin = himemmin ; 
} 
#endif /* DEBUG */
#ifdef DEBUG
void zsearchmem ( p ) 
halfword p ; 
{integer q  ; 
  {register integer for_end; q = 0 ; for_end = lomemmax ; if ( q <= for_end) 
  do 
    {
      if ( mem [ q ] .hhfield .v.RH == p ) 
      {
	printnl ( 323 ) ; 
	printint ( q ) ; 
	printchar ( 41 ) ; 
      } 
      if ( mem [ q ] .hhfield .lhfield == p ) 
      {
	printnl ( 324 ) ; 
	printint ( q ) ; 
	printchar ( 41 ) ; 
      } 
    } 
  while ( q++ < for_end ) ; } 
  {register integer for_end; q = himemmin ; for_end = memend ; if ( q <= 
  for_end) do 
    {
      if ( mem [ q ] .hhfield .v.RH == p ) 
      {
	printnl ( 323 ) ; 
	printint ( q ) ; 
	printchar ( 41 ) ; 
      } 
      if ( mem [ q ] .hhfield .lhfield == p ) 
      {
	printnl ( 324 ) ; 
	printint ( q ) ; 
	printchar ( 41 ) ; 
      } 
    } 
  while ( q++ < for_end ) ; } 
  {register integer for_end; q = 1 ; for_end = 2371 ; if ( q <= for_end) do 
    {
      if ( eqtb [ q ] .v.RH == p ) 
      {
	printnl ( 473 ) ; 
	printint ( q ) ; 
	printchar ( 41 ) ; 
      } 
    } 
  while ( q++ < for_end ) ; } 
} 
#endif /* DEBUG */
void zprintop ( c ) 
quarterword c ; 
{if ( c <= 15 ) 
  printtype ( c ) ; 
  else switch ( c ) 
  {case 30 : 
    print ( 348 ) ; 
    break ; 
  case 31 : 
    print ( 349 ) ; 
    break ; 
  case 32 : 
    print ( 350 ) ; 
    break ; 
  case 33 : 
    print ( 351 ) ; 
    break ; 
  case 34 : 
    print ( 352 ) ; 
    break ; 
  case 35 : 
    print ( 353 ) ; 
    break ; 
  case 36 : 
    print ( 354 ) ; 
    break ; 
  case 37 : 
    print ( 355 ) ; 
    break ; 
  case 38 : 
    print ( 356 ) ; 
    break ; 
  case 39 : 
    print ( 357 ) ; 
    break ; 
  case 40 : 
    print ( 358 ) ; 
    break ; 
  case 41 : 
    print ( 359 ) ; 
    break ; 
  case 42 : 
    print ( 360 ) ; 
    break ; 
  case 43 : 
    print ( 361 ) ; 
    break ; 
  case 44 : 
    print ( 362 ) ; 
    break ; 
  case 45 : 
    print ( 363 ) ; 
    break ; 
  case 46 : 
    print ( 364 ) ; 
    break ; 
  case 47 : 
    print ( 365 ) ; 
    break ; 
  case 48 : 
    print ( 366 ) ; 
    break ; 
  case 49 : 
    print ( 367 ) ; 
    break ; 
  case 50 : 
    print ( 368 ) ; 
    break ; 
  case 51 : 
    print ( 369 ) ; 
    break ; 
  case 52 : 
    print ( 370 ) ; 
    break ; 
  case 53 : 
    print ( 371 ) ; 
    break ; 
  case 54 : 
    print ( 372 ) ; 
    break ; 
  case 55 : 
    print ( 373 ) ; 
    break ; 
  case 56 : 
    print ( 374 ) ; 
    break ; 
  case 57 : 
    print ( 375 ) ; 
    break ; 
  case 58 : 
    print ( 376 ) ; 
    break ; 
  case 59 : 
    print ( 377 ) ; 
    break ; 
  case 60 : 
    print ( 378 ) ; 
    break ; 
  case 61 : 
    print ( 379 ) ; 
    break ; 
  case 62 : 
    print ( 380 ) ; 
    break ; 
  case 63 : 
    print ( 381 ) ; 
    break ; 
  case 64 : 
    print ( 382 ) ; 
    break ; 
  case 65 : 
    print ( 383 ) ; 
    break ; 
  case 66 : 
    print ( 384 ) ; 
    break ; 
  case 67 : 
    print ( 385 ) ; 
    break ; 
  case 68 : 
    print ( 386 ) ; 
    break ; 
  case 69 : 
    print ( 387 ) ; 
    break ; 
  case 70 : 
    print ( 388 ) ; 
    break ; 
  case 71 : 
    print ( 389 ) ; 
    break ; 
  case 72 : 
    print ( 390 ) ; 
    break ; 
  case 73 : 
    print ( 391 ) ; 
    break ; 
  case 74 : 
    print ( 392 ) ; 
    break ; 
  case 75 : 
    print ( 393 ) ; 
    break ; 
  case 76 : 
    print ( 394 ) ; 
    break ; 
  case 77 : 
    print ( 395 ) ; 
    break ; 
  case 78 : 
    print ( 396 ) ; 
    break ; 
  case 79 : 
    print ( 397 ) ; 
    break ; 
  case 80 : 
    print ( 398 ) ; 
    break ; 
  case 81 : 
    print ( 399 ) ; 
    break ; 
  case 82 : 
    print ( 400 ) ; 
    break ; 
  case 83 : 
    print ( 401 ) ; 
    break ; 
  case 84 : 
    print ( 402 ) ; 
    break ; 
  case 85 : 
    print ( 403 ) ; 
    break ; 
  case 86 : 
    print ( 404 ) ; 
    break ; 
  case 87 : 
    print ( 405 ) ; 
    break ; 
  case 88 : 
    printchar ( 43 ) ; 
    break ; 
  case 89 : 
    printchar ( 45 ) ; 
    break ; 
  case 90 : 
    printchar ( 42 ) ; 
    break ; 
  case 91 : 
    printchar ( 47 ) ; 
    break ; 
  case 92 : 
    print ( 406 ) ; 
    break ; 
  case 93 : 
    print ( 311 ) ; 
    break ; 
  case 94 : 
    print ( 407 ) ; 
    break ; 
  case 95 : 
    print ( 408 ) ; 
    break ; 
  case 96 : 
    printchar ( 60 ) ; 
    break ; 
  case 97 : 
    print ( 409 ) ; 
    break ; 
  case 98 : 
    printchar ( 62 ) ; 
    break ; 
  case 99 : 
    print ( 410 ) ; 
    break ; 
  case 100 : 
    printchar ( 61 ) ; 
    break ; 
  case 101 : 
    print ( 411 ) ; 
    break ; 
  case 102 : 
    print ( 38 ) ; 
    break ; 
  case 103 : 
    print ( 412 ) ; 
    break ; 
  case 104 : 
    print ( 413 ) ; 
    break ; 
  case 105 : 
    print ( 414 ) ; 
    break ; 
  case 106 : 
    print ( 415 ) ; 
    break ; 
  case 107 : 
    print ( 416 ) ; 
    break ; 
  case 108 : 
    print ( 417 ) ; 
    break ; 
  case 109 : 
    print ( 418 ) ; 
    break ; 
  case 110 : 
    print ( 419 ) ; 
    break ; 
  case 111 : 
    print ( 420 ) ; 
    break ; 
  case 112 : 
    print ( 421 ) ; 
    break ; 
  case 114 : 
    print ( 422 ) ; 
    break ; 
  case 115 : 
    print ( 423 ) ; 
    break ; 
  case 116 : 
    print ( 424 ) ; 
    break ; 
  case 117 : 
    print ( 425 ) ; 
    break ; 
  case 118 : 
    print ( 426 ) ; 
    break ; 
  case 119 : 
    print ( 427 ) ; 
    break ; 
  case 120 : 
    print ( 428 ) ; 
    break ; 
  case 121 : 
    print ( 429 ) ; 
    break ; 
    default: 
    print ( 322 ) ; 
    break ; 
  } 
} 
void fixdateandtime ( ) 
{dateandtime ( internal [ 16 ] , internal [ 15 ] , internal [ 14 ] , internal 
  [ 13 ] ) ; 
  internal [ 16 ] = internal [ 16 ] * 65536L ; 
  internal [ 15 ] = internal [ 15 ] * 65536L ; 
  internal [ 14 ] = internal [ 14 ] * 65536L ; 
  internal [ 13 ] = internal [ 13 ] * 65536L ; 
} 
halfword zidlookup ( j , l ) 
integer j ; 
integer l ; 
{/* 40 */ register halfword Result; integer h  ; 
  halfword p  ; 
  halfword k  ; 
  if ( l == 1 ) 
  {
    p = buffer [ j ] + 1 ; 
    hash [ p ] .v.RH = p - 1 ; 
    goto lab40 ; 
  } 
  h = buffer [ j ] ; 
  {register integer for_end; k = j + 1 ; for_end = j + l - 1 ; if ( k <= 
  for_end) do 
    {
      h = h + h + buffer [ k ] ; 
      while ( h >= 1777 ) h = h - 1777 ; 
    } 
  while ( k++ < for_end ) ; } 
  p = h + 257 ; 
  while ( true ) {
      
    if ( hash [ p ] .v.RH > 0 ) 
    if ( ( strstart [ nextstr [ hash [ p ] .v.RH ] ] - strstart [ hash [ p ] .v.RH ] ) == l ) 
    if ( streqbuf ( hash [ p ] .v.RH , j ) ) 
    goto lab40 ; 
    if ( hash [ p ] .lhfield == 0 ) 
    {
      if ( hash [ p ] .v.RH > 0 ) 
      {
	do {
	    if ( ( hashused == 257 ) ) 
	  overflow ( 472 , 2100 ) ; 
	  decr ( hashused ) ; 
	} while ( ! ( hash [ hashused ] .v.RH == 0 ) ) ; 
	hash [ p ] .lhfield = hashused ; 
	p = hashused ; 
      } 
      {
	if ( poolptr + l > maxpoolptr ) 
	if ( poolptr + l > poolsize ) 
	docompaction ( l ) ; 
	else maxpoolptr = poolptr + l ; 
      } 
      {register integer for_end; k = j ; for_end = j + l - 1 ; if ( k <= 
      for_end) do 
	{
	  strpool [ poolptr ] = buffer [ k ] ; 
	  incr ( poolptr ) ; 
	} 
      while ( k++ < for_end ) ; } 
      hash [ p ] .v.RH = makestring () ; 
      strref [ hash [ p ] .v.RH ] = 127 ; 
	;
#ifdef STAT
      incr ( stcount ) ; 
#endif /* STAT */
      goto lab40 ; 
    } 
    p = hash [ p ] .lhfield ; 
  } 
  lab40: Result = p ; 
  return(Result) ; 
} 
halfword znewnumtok ( v ) 
scaled v ; 
{register halfword Result; halfword p  ; 
  p = getnode ( 2 ) ; 
  mem [ p + 1 ] .cint = v ; 
  mem [ p ] .hhfield .b0 = 16 ; 
  mem [ p ] .hhfield .b1 = 15 ; 
  Result = p ; 
  return(Result) ; 
} 
void zflushtokenlist ( p ) 
halfword p ; 
{halfword q  ; 
  while ( p != 0 ) {
      
    q = p ; 
    p = mem [ p ] .hhfield .v.RH ; 
    if ( q >= himemmin ) 
    {
      mem [ q ] .hhfield .v.RH = avail ; 
      avail = q ; 
	;
#ifdef STAT
      decr ( dynused ) ; 
#endif /* STAT */
    } 
    else {
	
      switch ( mem [ q ] .hhfield .b0 ) 
      {case 1 : 
      case 2 : 
      case 16 : 
	; 
	break ; 
      case 4 : 
	{
	  if ( strref [ mem [ q + 1 ] .cint ] < 127 ) 
	  if ( strref [ mem [ q + 1 ] .cint ] > 1 ) 
	  decr ( strref [ mem [ q + 1 ] .cint ] ) ; 
	  else flushstring ( mem [ q + 1 ] .cint ) ; 
	} 
	break ; 
      case 3 : 
      case 5 : 
      case 7 : 
      case 11 : 
      case 9 : 
      case 6 : 
      case 8 : 
      case 10 : 
      case 14 : 
      case 13 : 
      case 12 : 
      case 17 : 
      case 18 : 
      case 19 : 
	{
	  gpointer = q ; 
	  tokenrecycle () ; 
	} 
	break ; 
	default: 
	confusion ( 503 ) ; 
	break ; 
      } 
      freenode ( q , 2 ) ; 
    } 
  } 
} 
void zdeletemacref ( p ) 
halfword p ; 
{if ( mem [ p ] .hhfield .lhfield == 0 ) 
  flushtokenlist ( p ) ; 
  else decr ( mem [ p ] .hhfield .lhfield ) ; 
} 
void zprintcmdmod ( c , m ) 
integer c ; 
integer m ; 
{switch ( c ) 
  {case 20 : 
    print ( 477 ) ; 
    break ; 
  case 76 : 
    print ( 476 ) ; 
    break ; 
  case 61 : 
    print ( 478 ) ; 
    break ; 
  case 78 : 
    print ( 475 ) ; 
    break ; 
  case 34 : 
    print ( 479 ) ; 
    break ; 
  case 80 : 
    print ( 58 ) ; 
    break ; 
  case 81 : 
    print ( 44 ) ; 
    break ; 
  case 59 : 
    print ( 480 ) ; 
    break ; 
  case 62 : 
    print ( 481 ) ; 
    break ; 
  case 29 : 
    print ( 482 ) ; 
    break ; 
  case 79 : 
    print ( 474 ) ; 
    break ; 
  case 83 : 
    print ( 468 ) ; 
    break ; 
  case 28 : 
    print ( 483 ) ; 
    break ; 
  case 9 : 
    print ( 484 ) ; 
    break ; 
  case 12 : 
    print ( 485 ) ; 
    break ; 
  case 15 : 
    print ( 486 ) ; 
    break ; 
  case 48 : 
    print ( 123 ) ; 
    break ; 
  case 65 : 
    print ( 91 ) ; 
    break ; 
  case 16 : 
    print ( 487 ) ; 
    break ; 
  case 17 : 
    print ( 488 ) ; 
    break ; 
  case 70 : 
    print ( 489 ) ; 
    break ; 
  case 49 : 
    print ( 322 ) ; 
    break ; 
  case 26 : 
    print ( 490 ) ; 
    break ; 
  case 10 : 
    printchar ( 92 ) ; 
    break ; 
  case 67 : 
    print ( 125 ) ; 
    break ; 
  case 66 : 
    print ( 93 ) ; 
    break ; 
  case 14 : 
    print ( 491 ) ; 
    break ; 
  case 11 : 
    print ( 492 ) ; 
    break ; 
  case 82 : 
    print ( 59 ) ; 
    break ; 
  case 19 : 
    print ( 493 ) ; 
    break ; 
  case 77 : 
    print ( 494 ) ; 
    break ; 
  case 30 : 
    print ( 495 ) ; 
    break ; 
  case 72 : 
    print ( 496 ) ; 
    break ; 
  case 37 : 
    print ( 497 ) ; 
    break ; 
  case 60 : 
    print ( 498 ) ; 
    break ; 
  case 71 : 
    print ( 499 ) ; 
    break ; 
  case 73 : 
    print ( 500 ) ; 
    break ; 
  case 74 : 
    print ( 501 ) ; 
    break ; 
  case 31 : 
    print ( 502 ) ; 
    break ; 
  case 1 : 
    if ( m == 0 ) 
    print ( 682 ) ; 
    else print ( 683 ) ; 
    break ; 
  case 2 : 
    print ( 465 ) ; 
    break ; 
  case 3 : 
    print ( 466 ) ; 
    break ; 
  case 18 : 
    if ( m <= 2 ) 
    if ( m == 1 ) 
    print ( 696 ) ; 
    else if ( m < 1 ) 
    print ( 469 ) ; 
    else print ( 697 ) ; 
    else if ( m == 55 ) 
    print ( 698 ) ; 
    else if ( m == 46 ) 
    print ( 699 ) ; 
    else print ( 700 ) ; 
    break ; 
  case 7 : 
    if ( m <= 1 ) 
    if ( m == 1 ) 
    print ( 703 ) ; 
    else print ( 470 ) ; 
    else if ( m == 2372 ) 
    print ( 701 ) ; 
    else print ( 702 ) ; 
    break ; 
  case 63 : 
    switch ( m ) 
    {case 1 : 
      print ( 705 ) ; 
      break ; 
    case 2 : 
      printchar ( 64 ) ; 
      break ; 
    case 3 : 
      print ( 706 ) ; 
      break ; 
      default: 
      print ( 704 ) ; 
      break ; 
    } 
    break ; 
  case 58 : 
    if ( m >= 2372 ) 
    if ( m == 2372 ) 
    print ( 717 ) ; 
    else if ( m == 2522 ) 
    print ( 718 ) ; 
    else print ( 719 ) ; 
    else if ( m < 2 ) 
    print ( 720 ) ; 
    else if ( m == 2 ) 
    print ( 721 ) ; 
    else print ( 722 ) ; 
    break ; 
  case 6 : 
    if ( m == 0 ) 
    print ( 732 ) ; 
    else print ( 629 ) ; 
    break ; 
  case 4 : 
  case 5 : 
    switch ( m ) 
    {case 1 : 
      print ( 759 ) ; 
      break ; 
    case 2 : 
      print ( 467 ) ; 
      break ; 
    case 3 : 
      print ( 760 ) ; 
      break ; 
      default: 
      print ( 761 ) ; 
      break ; 
    } 
    break ; 
  case 35 : 
  case 36 : 
  case 39 : 
  case 57 : 
  case 47 : 
  case 52 : 
  case 38 : 
  case 45 : 
  case 56 : 
  case 50 : 
  case 53 : 
  case 54 : 
    printop ( m ) ; 
    break ; 
  case 32 : 
    printtype ( m ) ; 
    break ; 
  case 84 : 
    if ( m == 0 ) 
    print ( 960 ) ; 
    else print ( 961 ) ; 
    break ; 
  case 25 : 
    switch ( m ) 
    {case 0 : 
      print ( 273 ) ; 
      break ; 
    case 1 : 
      print ( 274 ) ; 
      break ; 
    case 2 : 
      print ( 275 ) ; 
      break ; 
      default: 
      print ( 967 ) ; 
      break ; 
    } 
    break ; 
  case 23 : 
    if ( m == 0 ) 
    print ( 968 ) ; 
    else print ( 969 ) ; 
    break ; 
  case 24 : 
    switch ( m ) 
    {case 0 : 
      print ( 983 ) ; 
      break ; 
    case 1 : 
      print ( 984 ) ; 
      break ; 
    case 2 : 
      print ( 985 ) ; 
      break ; 
    case 3 : 
      print ( 986 ) ; 
      break ; 
      default: 
      print ( 987 ) ; 
      break ; 
    } 
    break ; 
  case 33 : 
  case 64 : 
    {
      if ( c == 33 ) 
      print ( 990 ) ; 
      else print ( 991 ) ; 
      print ( 992 ) ; 
      print ( hash [ m ] .v.RH ) ; 
    } 
    break ; 
  case 43 : 
    if ( m == 0 ) 
    print ( 993 ) ; 
    else print ( 994 ) ; 
    break ; 
  case 13 : 
    print ( 995 ) ; 
    break ; 
  case 55 : 
  case 46 : 
  case 51 : 
    {
      printcmdmod ( 18 , c ) ; 
      print ( 996 ) ; 
      println () ; 
      showtokenlist ( mem [ mem [ m ] .hhfield .v.RH ] .hhfield .v.RH , 0 ,      1000 , 0 ) ; 
    } 
    break ; 
  case 8 : 
    print ( 997 ) ; 
    break ; 
  case 42 : 
    print ( intname [ m ] ) ; 
    break ; 
  case 69 : 
    if ( m == 1 ) 
    print ( 1007 ) ; 
    else if ( m == 0 ) 
    print ( 1006 ) ; 
    else print ( 1008 ) ; 
    break ; 
  case 68 : 
    if ( m == 6 ) 
    print ( 1009 ) ; 
    else if ( m == 13 ) 
    print ( 1011 ) ; 
    else print ( 1010 ) ; 
    break ; 
  case 21 : 
    if ( m == 4 ) 
    print ( 1020 ) ; 
    else print ( 1021 ) ; 
    break ; 
  case 27 : 
    if ( m < 1 ) 
    print ( 1034 ) ; 
    else if ( m == 1 ) 
    print ( 1035 ) ; 
    else print ( 1036 ) ; 
    break ; 
  case 22 : 
    switch ( m ) 
    {case 0 : 
      print ( 1051 ) ; 
      break ; 
    case 1 : 
      print ( 1052 ) ; 
      break ; 
    case 2 : 
      print ( 1053 ) ; 
      break ; 
    case 3 : 
      print ( 1054 ) ; 
      break ; 
      default: 
      print ( 1055 ) ; 
      break ; 
    } 
    break ; 
  case 75 : 
    switch ( m ) 
    {case 0 : 
      print ( 1073 ) ; 
      break ; 
    case 1 : 
      print ( 1074 ) ; 
      break ; 
    case 2 : 
      print ( 1076 ) ; 
      break ; 
    case 3 : 
      print ( 1078 ) ; 
      break ; 
    case 5 : 
      print ( 1075 ) ; 
      break ; 
    case 6 : 
      print ( 1077 ) ; 
      break ; 
    case 7 : 
      print ( 1079 ) ; 
      break ; 
    case 11 : 
      print ( 1080 ) ; 
      break ; 
      default: 
      print ( 1081 ) ; 
      break ; 
    } 
    break ; 
    default: 
    print ( 614 ) ; 
    break ; 
  } 
} 
void zshowmacro ( p , q , l ) 
halfword p ; 
integer q ; 
integer l ; 
{/* 10 */ halfword r  ; 
  p = mem [ p ] .hhfield .v.RH ; 
  while ( mem [ p ] .hhfield .lhfield > 7 ) {
      
    r = mem [ p ] .hhfield .v.RH ; 
    mem [ p ] .hhfield .v.RH = 0 ; 
    showtokenlist ( p , 0 , l , 0 ) ; 
    mem [ p ] .hhfield .v.RH = r ; 
    p = r ; 
    if ( l > 0 ) 
    l = l - tally ; 
    else goto lab10 ; 
  } 
  tally = 0 ; 
  switch ( mem [ p ] .hhfield .lhfield ) 
  {case 0 : 
    print ( 513 ) ; 
    break ; 
  case 1 : 
  case 2 : 
  case 3 : 
    {
      printchar ( 60 ) ; 
      printcmdmod ( 58 , mem [ p ] .hhfield .lhfield ) ; 
      print ( 514 ) ; 
    } 
    break ; 
  case 4 : 
    print ( 515 ) ; 
    break ; 
  case 5 : 
    print ( 516 ) ; 
    break ; 
  case 6 : 
    print ( 517 ) ; 
    break ; 
  case 7 : 
    print ( 518 ) ; 
    break ; 
  } 
  showtokenlist ( mem [ p ] .hhfield .v.RH , q , l - tally , 0 ) ; 
  lab10: ; 
} 
void zinitbignode ( p ) 
halfword p ; 
{halfword q  ; 
  smallnumber s  ; 
  s = bignodesize [ mem [ p ] .hhfield .b0 ] ; 
  q = getnode ( s ) ; 
  do {
      s = s - 2 ; 
    {
      mem [ q + s ] .hhfield .b0 = 19 ; 
      serialno = serialno + 64 ; 
      mem [ q + s + 1 ] .cint = serialno ; 
    } 
    mem [ q + s ] .hhfield .b1 = halfp ( s ) + sector0 [ mem [ p ] .hhfield .b0 ] ; 
    mem [ q + s ] .hhfield .v.RH = 0 ; 
  } while ( ! ( s == 0 ) ) ; 
  mem [ q ] .hhfield .v.RH = p ; 
  mem [ p + 1 ] .cint = q ; 
} 
halfword idtransform ( ) 
{register halfword Result; halfword p, q, r  ; 
  p = getnode ( 2 ) ; 
  mem [ p ] .hhfield .b0 = 12 ; 
  mem [ p ] .hhfield .b1 = 14 ; 
  mem [ p + 1 ] .cint = 0 ; 
  initbignode ( p ) ; 
  q = mem [ p + 1 ] .cint ; 
  r = q + 12 ; 
  do {
      r = r - 2 ; 
    mem [ r ] .hhfield .b0 = 16 ; 
    mem [ r + 1 ] .cint = 0 ; 
  } while ( ! ( r == q ) ) ; 
  mem [ q + 5 ] .cint = 65536L ; 
  mem [ q + 11 ] .cint = 65536L ; 
  Result = p ; 
  return(Result) ; 
} 
void znewroot ( x ) 
halfword x ; 
{halfword p  ; 
  p = getnode ( 2 ) ; 
  mem [ p ] .hhfield .b0 = 0 ; 
  mem [ p ] .hhfield .b1 = 0 ; 
  mem [ p ] .hhfield .v.RH = x ; 
  eqtb [ x ] .v.RH = p ; 
} 
void zprintvariablename ( p ) 
halfword p ; 
{/* 40 10 */ halfword q  ; 
  halfword r  ; 
  while ( mem [ p ] .hhfield .b1 >= 5 ) {
      
    switch ( mem [ p ] .hhfield .b1 ) 
    {case 5 : 
      printchar ( 120 ) ; 
      break ; 
    case 6 : 
      printchar ( 121 ) ; 
      break ; 
    case 7 : 
      print ( 521 ) ; 
      break ; 
    case 8 : 
      print ( 522 ) ; 
      break ; 
    case 9 : 
      print ( 523 ) ; 
      break ; 
    case 10 : 
      print ( 524 ) ; 
      break ; 
    case 11 : 
      print ( 525 ) ; 
      break ; 
    case 12 : 
      print ( 526 ) ; 
      break ; 
    case 13 : 
      print ( 527 ) ; 
      break ; 
    case 14 : 
      {
	print ( 528 ) ; 
	printint ( p + 0 ) ; 
	goto lab10 ; 
      } 
      break ; 
    } 
    print ( 529 ) ; 
    p = mem [ p - sectoroffset [ mem [ p ] .hhfield .b1 ] ] .hhfield .v.RH ; 
  } 
  q = 0 ; 
  while ( mem [ p ] .hhfield .b1 > 1 ) {
      
    if ( mem [ p ] .hhfield .b1 == 3 ) 
    {
      r = newnumtok ( mem [ p + 2 ] .cint ) ; 
      do {
	  p = mem [ p ] .hhfield .v.RH ; 
      } while ( ! ( mem [ p ] .hhfield .b1 == 4 ) ) ; 
    } 
    else if ( mem [ p ] .hhfield .b1 == 2 ) 
    {
      p = mem [ p ] .hhfield .v.RH ; 
      goto lab40 ; 
    } 
    else {
	
      if ( mem [ p ] .hhfield .b1 != 4 ) 
      confusion ( 520 ) ; 
      r = getavail () ; 
      mem [ r ] .hhfield .lhfield = mem [ p + 2 ] .hhfield .lhfield ; 
    } 
    mem [ r ] .hhfield .v.RH = q ; 
    q = r ; 
    lab40: p = mem [ p + 2 ] .hhfield .v.RH ; 
  } 
  r = getavail () ; 
  mem [ r ] .hhfield .lhfield = mem [ p ] .hhfield .v.RH ; 
  mem [ r ] .hhfield .v.RH = q ; 
  if ( mem [ p ] .hhfield .b1 == 1 ) 
  print ( 519 ) ; 
  showtokenlist ( r , 0 , 2147483647L , tally ) ; 
  flushtokenlist ( r ) ; 
  lab10: ; 
} 
boolean zinteresting ( p ) 
halfword p ; 
{register boolean Result; smallnumber t  ; 
  if ( internal [ 3 ] > 0 ) 
  Result = true ; 
  else {
      
    t = mem [ p ] .hhfield .b1 ; 
    if ( t >= 5 ) 
    if ( t != 14 ) 
    t = mem [ mem [ p - sectoroffset [ t ] ] .hhfield .v.RH ] .hhfield .b1 ; 
    Result = ( t != 14 ) ; 
  } 
  return(Result) ; 
} 
halfword znewstructure ( p ) 
halfword p ; 
{register halfword Result; halfword q, r  ; 
  switch ( mem [ p ] .hhfield .b1 ) 
  {case 0 : 
    {
      q = mem [ p ] .hhfield .v.RH ; 
      r = getnode ( 2 ) ; 
      eqtb [ q ] .v.RH = r ; 
    } 
    break ; 
  case 3 : 
    {
      q = p ; 
      do {
	  q = mem [ q ] .hhfield .v.RH ; 
      } while ( ! ( mem [ q ] .hhfield .b1 == 4 ) ) ; 
      q = mem [ q + 2 ] .hhfield .v.RH ; 
      r = q + 1 ; 
      do {
	  q = r ; 
	r = mem [ r ] .hhfield .v.RH ; 
      } while ( ! ( r == p ) ) ; 
      r = getnode ( 3 ) ; 
      mem [ q ] .hhfield .v.RH = r ; 
      mem [ r + 2 ] .cint = mem [ p + 2 ] .cint ; 
    } 
    break ; 
  case 4 : 
    {
      q = mem [ p + 2 ] .hhfield .v.RH ; 
      r = mem [ q + 1 ] .hhfield .lhfield ; 
      do {
	  q = r ; 
	r = mem [ r ] .hhfield .v.RH ; 
      } while ( ! ( r == p ) ) ; 
      r = getnode ( 3 ) ; 
      mem [ q ] .hhfield .v.RH = r ; 
      mem [ r + 2 ] = mem [ p + 2 ] ; 
      if ( mem [ p + 2 ] .hhfield .lhfield == 0 ) 
      {
	q = mem [ p + 2 ] .hhfield .v.RH + 1 ; 
	while ( mem [ q ] .hhfield .v.RH != p ) q = mem [ q ] .hhfield .v.RH ; 
	mem [ q ] .hhfield .v.RH = r ; 
      } 
    } 
    break ; 
    default: 
    confusion ( 530 ) ; 
    break ; 
  } 
  mem [ r ] .hhfield .v.RH = mem [ p ] .hhfield .v.RH ; 
  mem [ r ] .hhfield .b0 = 21 ; 
  mem [ r ] .hhfield .b1 = mem [ p ] .hhfield .b1 ; 
  mem [ r + 1 ] .hhfield .lhfield = p ; 
  mem [ p ] .hhfield .b1 = 2 ; 
  q = getnode ( 3 ) ; 
  mem [ p ] .hhfield .v.RH = q ; 
  mem [ r + 1 ] .hhfield .v.RH = q ; 
  mem [ q + 2 ] .hhfield .v.RH = r ; 
  mem [ q ] .hhfield .b0 = 0 ; 
  mem [ q ] .hhfield .b1 = 4 ; 
  mem [ q ] .hhfield .v.RH = 9 ; 
  mem [ q + 2 ] .hhfield .lhfield = 0 ; 
  Result = r ; 
  return(Result) ; 
} 
halfword zfindvariable ( t ) 
halfword t ; 
{/* 10 */ register halfword Result; halfword p, q, r, s  ; 
  halfword pp, qq, rr, ss  ; 
  integer n  ; 
  memoryword saveword  ; 
  p = mem [ t ] .hhfield .lhfield ; 
  t = mem [ t ] .hhfield .v.RH ; 
  if ( eqtb [ p ] .lhfield % 85 != 43 ) 
  {
    Result = 0 ; 
    goto lab10 ; 
  } 
  if ( eqtb [ p ] .v.RH == 0 ) 
  newroot ( p ) ; 
  p = eqtb [ p ] .v.RH ; 
  pp = p ; 
  while ( t != 0 ) {
      
    if ( mem [ pp ] .hhfield .b0 != 21 ) 
    {
      if ( mem [ pp ] .hhfield .b0 > 21 ) 
      {
	Result = 0 ; 
	goto lab10 ; 
      } 
      ss = newstructure ( pp ) ; 
      if ( p == pp ) 
      p = ss ; 
      pp = ss ; 
    } 
    if ( mem [ p ] .hhfield .b0 != 21 ) 
    p = newstructure ( p ) ; 
    if ( t < himemmin ) 
    {
      n = mem [ t + 1 ] .cint ; 
      pp = mem [ mem [ pp + 1 ] .hhfield .lhfield ] .hhfield .v.RH ; 
      q = mem [ mem [ p + 1 ] .hhfield .lhfield ] .hhfield .v.RH ; 
      saveword = mem [ q + 2 ] ; 
      mem [ q + 2 ] .cint = 2147483647L ; 
      s = p + 1 ; 
      do {
	  r = s ; 
	s = mem [ s ] .hhfield .v.RH ; 
      } while ( ! ( n <= mem [ s + 2 ] .cint ) ) ; 
      if ( n == mem [ s + 2 ] .cint ) 
      p = s ; 
      else {
	  
	p = getnode ( 3 ) ; 
	mem [ r ] .hhfield .v.RH = p ; 
	mem [ p ] .hhfield .v.RH = s ; 
	mem [ p + 2 ] .cint = n ; 
	mem [ p ] .hhfield .b1 = 3 ; 
	mem [ p ] .hhfield .b0 = 0 ; 
      } 
      mem [ q + 2 ] = saveword ; 
    } 
    else {
	
      n = mem [ t ] .hhfield .lhfield ; 
      ss = mem [ pp + 1 ] .hhfield .lhfield ; 
      do {
	  rr = ss ; 
	ss = mem [ ss ] .hhfield .v.RH ; 
      } while ( ! ( n <= mem [ ss + 2 ] .hhfield .lhfield ) ) ; 
      if ( n < mem [ ss + 2 ] .hhfield .lhfield ) 
      {
	qq = getnode ( 3 ) ; 
	mem [ rr ] .hhfield .v.RH = qq ; 
	mem [ qq ] .hhfield .v.RH = ss ; 
	mem [ qq + 2 ] .hhfield .lhfield = n ; 
	mem [ qq ] .hhfield .b1 = 4 ; 
	mem [ qq ] .hhfield .b0 = 0 ; 
	mem [ qq + 2 ] .hhfield .v.RH = pp ; 
	ss = qq ; 
      } 
      if ( p == pp ) 
      {
	p = ss ; 
	pp = ss ; 
      } 
      else {
	  
	pp = ss ; 
	s = mem [ p + 1 ] .hhfield .lhfield ; 
	do {
	    r = s ; 
	  s = mem [ s ] .hhfield .v.RH ; 
	} while ( ! ( n <= mem [ s + 2 ] .hhfield .lhfield ) ) ; 
	if ( n == mem [ s + 2 ] .hhfield .lhfield ) 
	p = s ; 
	else {
	    
	  q = getnode ( 3 ) ; 
	  mem [ r ] .hhfield .v.RH = q ; 
	  mem [ q ] .hhfield .v.RH = s ; 
	  mem [ q + 2 ] .hhfield .lhfield = n ; 
	  mem [ q ] .hhfield .b1 = 4 ; 
	  mem [ q ] .hhfield .b0 = 0 ; 
	  mem [ q + 2 ] .hhfield .v.RH = p ; 
	  p = q ; 
	} 
      } 
    } 
    t = mem [ t ] .hhfield .v.RH ; 
  } 
  if ( mem [ pp ] .hhfield .b0 >= 21 ) 
  if ( mem [ pp ] .hhfield .b0 == 21 ) 
  pp = mem [ pp + 1 ] .hhfield .lhfield ; 
  else {
      
    Result = 0 ; 
    goto lab10 ; 
  } 
  if ( mem [ p ] .hhfield .b0 == 21 ) 
  p = mem [ p + 1 ] .hhfield .lhfield ; 
  if ( mem [ p ] .hhfield .b0 == 0 ) 
  {
    if ( mem [ pp ] .hhfield .b0 == 0 ) 
    {
      mem [ pp ] .hhfield .b0 = 15 ; 
      mem [ pp + 1 ] .cint = 0 ; 
    } 
    mem [ p ] .hhfield .b0 = mem [ pp ] .hhfield .b0 ; 
    mem [ p + 1 ] .cint = 0 ; 
  } 
  Result = p ; 
  lab10: ; 
  return(Result) ; 
}