#define EXTERN extern
#include "mfd.h"

void zpathintersection ( h , hh ) 
halfword h ; 
halfword hh ; 
{/* 10 */ halfword p, pp  ; 
  integer n, nn  ; 
  if ( mem [ h ] .hhfield .b1 == 0 ) 
  {
    mem [ h + 5 ] .cint = mem [ h + 1 ] .cint ; 
    mem [ h + 3 ] .cint = mem [ h + 1 ] .cint ; 
    mem [ h + 6 ] .cint = mem [ h + 2 ] .cint ; 
    mem [ h + 4 ] .cint = mem [ h + 2 ] .cint ; 
    mem [ h ] .hhfield .b1 = 1 ; 
  } 
  if ( mem [ hh ] .hhfield .b1 == 0 ) 
  {
    mem [ hh + 5 ] .cint = mem [ hh + 1 ] .cint ; 
    mem [ hh + 3 ] .cint = mem [ hh + 1 ] .cint ; 
    mem [ hh + 6 ] .cint = mem [ hh + 2 ] .cint ; 
    mem [ hh + 4 ] .cint = mem [ hh + 2 ] .cint ; 
    mem [ hh ] .hhfield .b1 = 1 ; 
  } 
  tolstep = 0 ; 
  do {
      n = -65536L ; 
    p = h ; 
    do {
	if ( mem [ p ] .hhfield .b1 != 0 ) 
      {
	nn = -65536L ; 
	pp = hh ; 
	do {
	    if ( mem [ pp ] .hhfield .b1 != 0 ) 
	  {
	    cubicintersection ( p , pp ) ; 
	    if ( curt > 0 ) 
	    {
	      curt = curt + n ; 
	      curtt = curtt + nn ; 
	      goto lab10 ; 
	    } 
	  } 
	  nn = nn + 65536L ; 
	  pp = mem [ pp ] .hhfield .v.RH ; 
	} while ( ! ( pp == hh ) ) ; 
      } 
      n = n + 65536L ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } while ( ! ( p == h ) ) ; 
    tolstep = tolstep + 3 ; 
  } while ( ! ( tolstep > 3 ) ) ; 
  curt = -65536L ; 
  curtt = -65536L ; 
  lab10: ; 
} 
void zopenawindow ( k , r0 , c0 , r1 , c1 , x , y ) 
windownumber k ; 
scaled r0 ; 
scaled c0 ; 
scaled r1 ; 
scaled c1 ; 
scaled x ; 
scaled y ; 
{integer m, n  ; 
  if ( r0 < 0 ) 
  r0 = 0 ; 
  else r0 = roundunscaled ( r0 ) ; 
  r1 = roundunscaled ( r1 ) ; 
  if ( r1 > screendepth ) 
  r1 = screendepth ; 
  if ( r1 < r0 ) 
  if ( r0 > screendepth ) 
  r0 = r1 ; 
  else r1 = r0 ; 
  if ( c0 < 0 ) 
  c0 = 0 ; 
  else c0 = roundunscaled ( c0 ) ; 
  c1 = roundunscaled ( c1 ) ; 
  if ( c1 > screenwidth ) 
  c1 = screenwidth ; 
  if ( c1 < c0 ) 
  if ( c0 > screenwidth ) 
  c0 = c1 ; 
  else c1 = c0 ; 
  windowopen [ k ] = true ; 
  incr ( windowtime [ k ] ) ; 
  leftcol [ k ] = c0 ; 
  rightcol [ k ] = c1 ; 
  toprow [ k ] = r0 ; 
  botrow [ k ] = r1 ; 
  m = roundunscaled ( x ) ; 
  n = roundunscaled ( y ) - 1 ; 
  mwindow [ k ] = c0 - m ; 
  nwindow [ k ] = r0 + n ; 
  {
    if ( ! screenstarted ) 
    {
      screenOK = initscreen () ; 
      screenstarted = true ; 
    } 
  } 
  if ( screenOK ) 
  {
    blankrectangle ( c0 , c1 , r0 , r1 ) ; 
    updatescreen () ; 
  } 
} 
void zdispedges ( k ) 
windownumber k ; 
{/* 30 40 */ halfword p, q  ; 
  boolean alreadythere  ; 
  integer r  ; 
  screencol n  ; 
  integer w, ww  ; 
  pixelcolor b  ; 
  integer m, mm  ; 
  integer d  ; 
  integer madjustment  ; 
  integer rightedge  ; 
  screencol mincol  ; 
  if ( screenOK ) 
  if ( leftcol [ k ] < rightcol [ k ] ) 
  if ( toprow [ k ] < botrow [ k ] ) 
  {
    alreadythere = false ; 
    if ( mem [ curedges + 3 ] .hhfield .v.RH == k ) 
    if ( mem [ curedges + 4 ] .cint == windowtime [ k ] ) 
    alreadythere = true ; 
    if ( ! alreadythere ) 
    blankrectangle ( leftcol [ k ] , rightcol [ k ] , toprow [ k ] , botrow [ 
    k ] ) ; 
    madjustment = mwindow [ k ] - mem [ curedges + 3 ] .hhfield .lhfield ; 
    rightedge = 8 * ( rightcol [ k ] - madjustment ) ; 
    mincol = leftcol [ k ] ; 
    p = mem [ curedges ] .hhfield .v.RH ; 
    r = nwindow [ k ] - ( mem [ curedges + 1 ] .hhfield .lhfield - 4096 ) ; 
    while ( ( p != curedges ) && ( r >= toprow [ k ] ) ) {
	
      if ( r < botrow [ k ] ) 
      {
	if ( mem [ p + 1 ] .hhfield .lhfield > 1 ) 
	sortedges ( p ) ; 
	else if ( mem [ p + 1 ] .hhfield .lhfield == 1 ) 
	if ( alreadythere ) 
	goto lab30 ; 
	mem [ p + 1 ] .hhfield .lhfield = 1 ; 
	n = 0 ; 
	ww = 0 ; 
	m = -1 ; 
	w = 0 ; 
	q = mem [ p + 1 ] .hhfield .v.RH ; 
	rowtransition [ 0 ] = mincol ; 
	while ( true ) {
	    
	  if ( q == memtop ) 
	  d = rightedge ; 
	  else d = mem [ q ] .hhfield .lhfield ; 
	  mm = ( d / 8 ) + madjustment ; 
	  if ( mm != m ) 
	  {
	    if ( w <= 0 ) 
	    {
	      if ( ww > 0 ) 
	      if ( m > mincol ) 
	      {
		if ( n == 0 ) 
		if ( alreadythere ) 
		{
		  b = 0 ; 
		  incr ( n ) ; 
		} 
		else b = 1 ; 
		else incr ( n ) ; 
		rowtransition [ n ] = m ; 
	      } 
	    } 
	    else if ( ww <= 0 ) 
	    if ( m > mincol ) 
	    {
	      if ( n == 0 ) 
	      b = 1 ; 
	      incr ( n ) ; 
	      rowtransition [ n ] = m ; 
	    } 
	    m = mm ; 
	    w = ww ; 
	  } 
	  if ( d >= rightedge ) 
	  goto lab40 ; 
	  ww = ww + ( d % 8 ) - 4 ; 
	  q = mem [ q ] .hhfield .v.RH ; 
	} 
	lab40: if ( alreadythere || ( ww > 0 ) ) 
	{
	  if ( n == 0 ) 
	  if ( ww > 0 ) 
	  b = 1 ; 
	  else b = 0 ; 
	  incr ( n ) ; 
	  rowtransition [ n ] = rightcol [ k ] ; 
	} 
	else if ( n == 0 ) 
	goto lab30 ; 
	paintrow ( r , b , rowtransition , n ) ; 
	lab30: ; 
      } 
      p = mem [ p ] .hhfield .v.RH ; 
      decr ( r ) ; 
    } 
    updatescreen () ; 
    incr ( windowtime [ k ] ) ; 
    mem [ curedges + 3 ] .hhfield .v.RH = k ; 
    mem [ curedges + 4 ] .cint = windowtime [ k ] ; 
  } 
} 
fraction zmaxcoef ( p ) 
halfword p ; 
{register fraction Result; fraction x  ; 
  x = 0 ; 
  while ( mem [ p ] .hhfield .lhfield != 0 ) {
      
    if ( abs ( mem [ p + 1 ] .cint ) > x ) 
    x = abs ( mem [ p + 1 ] .cint ) ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  Result = x ; 
  return(Result) ; 
} 
halfword zpplusq ( p , q , t ) 
halfword p ; 
halfword q ; 
smallnumber t ; 
{/* 30 */ register halfword Result; halfword pp, qq  ; 
  halfword r, s  ; 
  integer threshold  ; 
  integer v  ; 
  if ( t == 17 ) 
  threshold = 2685 ; 
  else threshold = 8 ; 
  r = memtop - 1 ; 
  pp = mem [ p ] .hhfield .lhfield ; 
  qq = mem [ q ] .hhfield .lhfield ; 
  while ( true ) if ( pp == qq ) 
  if ( pp == 0 ) 
  goto lab30 ; 
  else {
      
    v = mem [ p + 1 ] .cint + mem [ q + 1 ] .cint ; 
    mem [ p + 1 ] .cint = v ; 
    s = p ; 
    p = mem [ p ] .hhfield .v.RH ; 
    pp = mem [ p ] .hhfield .lhfield ; 
    if ( abs ( v ) < threshold ) 
    freenode ( s , 2 ) ; 
    else {
	
      if ( abs ( v ) >= 626349397L ) 
      if ( watchcoefs ) 
      {
	mem [ qq ] .hhfield .b0 = 0 ; 
	fixneeded = true ; 
      } 
      mem [ r ] .hhfield .v.RH = s ; 
      r = s ; 
    } 
    q = mem [ q ] .hhfield .v.RH ; 
    qq = mem [ q ] .hhfield .lhfield ; 
  } 
  else if ( mem [ pp + 1 ] .cint < mem [ qq + 1 ] .cint ) 
  {
    s = getnode ( 2 ) ; 
    mem [ s ] .hhfield .lhfield = qq ; 
    mem [ s + 1 ] .cint = mem [ q + 1 ] .cint ; 
    q = mem [ q ] .hhfield .v.RH ; 
    qq = mem [ q ] .hhfield .lhfield ; 
    mem [ r ] .hhfield .v.RH = s ; 
    r = s ; 
  } 
  else {
      
    mem [ r ] .hhfield .v.RH = p ; 
    r = p ; 
    p = mem [ p ] .hhfield .v.RH ; 
    pp = mem [ p ] .hhfield .lhfield ; 
  } 
  lab30: mem [ p + 1 ] .cint = slowadd ( mem [ p + 1 ] .cint , mem [ q + 1 ] 
  .cint ) ; 
  mem [ r ] .hhfield .v.RH = p ; 
  depfinal = p ; 
  Result = mem [ memtop - 1 ] .hhfield .v.RH ; 
  return(Result) ; 
} 
halfword zptimesv ( p , v , t0 , t1 , visscaled ) 
halfword p ; 
integer v ; 
smallnumber t0 ; 
smallnumber t1 ; 
boolean visscaled ; 
{register halfword Result; halfword r, s  ; 
  integer w  ; 
  integer threshold  ; 
  boolean scalingdown  ; 
  if ( t0 != t1 ) 
  scalingdown = true ; 
  else scalingdown = ! visscaled ; 
  if ( t1 == 17 ) 
  threshold = 1342 ; 
  else threshold = 4 ; 
  r = memtop - 1 ; 
  while ( mem [ p ] .hhfield .lhfield != 0 ) {
      
    if ( scalingdown ) 
    w = takefraction ( v , mem [ p + 1 ] .cint ) ; 
    else w = takescaled ( v , mem [ p + 1 ] .cint ) ; 
    if ( abs ( w ) <= threshold ) 
    {
      s = mem [ p ] .hhfield .v.RH ; 
      freenode ( p , 2 ) ; 
      p = s ; 
    } 
    else {
	
      if ( abs ( w ) >= 626349397L ) 
      {
	fixneeded = true ; 
	mem [ mem [ p ] .hhfield .lhfield ] .hhfield .b0 = 0 ; 
      } 
      mem [ r ] .hhfield .v.RH = p ; 
      r = p ; 
      mem [ p + 1 ] .cint = w ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } 
  } 
  mem [ r ] .hhfield .v.RH = p ; 
  if ( visscaled ) 
  mem [ p + 1 ] .cint = takescaled ( mem [ p + 1 ] .cint , v ) ; 
  else mem [ p + 1 ] .cint = takefraction ( mem [ p + 1 ] .cint , v ) ; 
  Result = mem [ memtop - 1 ] .hhfield .v.RH ; 
  return(Result) ; 
} 
halfword zpwithxbecomingq ( p , x , q , t ) 
halfword p ; 
halfword x ; 
halfword q ; 
smallnumber t ; 
{register halfword Result; halfword r, s  ; 
  integer v  ; 
  integer sx  ; 
  s = p ; 
  r = memtop - 1 ; 
  sx = mem [ x + 1 ] .cint ; 
  while ( mem [ mem [ s ] .hhfield .lhfield + 1 ] .cint > sx ) {
      
    r = s ; 
    s = mem [ s ] .hhfield .v.RH ; 
  } 
  if ( mem [ s ] .hhfield .lhfield != x ) 
  Result = p ; 
  else {
      
    mem [ memtop - 1 ] .hhfield .v.RH = p ; 
    mem [ r ] .hhfield .v.RH = mem [ s ] .hhfield .v.RH ; 
    v = mem [ s + 1 ] .cint ; 
    freenode ( s , 2 ) ; 
    Result = pplusfq ( mem [ memtop - 1 ] .hhfield .v.RH , v , q , t , 17 ) ; 
  } 
  return(Result) ; 
} 
void znewdep ( q , p ) 
halfword q ; 
halfword p ; 
{halfword r  ; 
  mem [ q + 1 ] .hhfield .v.RH = p ; 
  mem [ q + 1 ] .hhfield .lhfield = 13 ; 
  r = mem [ 13 ] .hhfield .v.RH ; 
  mem [ depfinal ] .hhfield .v.RH = r ; 
  mem [ r + 1 ] .hhfield .lhfield = depfinal ; 
  mem [ 13 ] .hhfield .v.RH = q ; 
} 
halfword zconstdependency ( v ) 
scaled v ; 
{register halfword Result; depfinal = getnode ( 2 ) ; 
  mem [ depfinal + 1 ] .cint = v ; 
  mem [ depfinal ] .hhfield .lhfield = 0 ; 
  Result = depfinal ; 
  return(Result) ; 
} 
halfword zsingledependency ( p ) 
halfword p ; 
{register halfword Result; halfword q  ; 
  integer m  ; 
  m = mem [ p + 1 ] .cint % 64 ; 
  if ( m > 28 ) 
  Result = constdependency ( 0 ) ; 
  else {
      
    q = getnode ( 2 ) ; 
    mem [ q + 1 ] .cint = twotothe [ 28 - m ] ; 
    mem [ q ] .hhfield .lhfield = p ; 
    mem [ q ] .hhfield .v.RH = constdependency ( 0 ) ; 
    Result = q ; 
  } 
  return(Result) ; 
} 
halfword zcopydeplist ( p ) 
halfword p ; 
{/* 30 */ register halfword Result; halfword q  ; 
  q = getnode ( 2 ) ; 
  depfinal = q ; 
  while ( true ) {
      
    mem [ depfinal ] .hhfield .lhfield = mem [ p ] .hhfield .lhfield ; 
    mem [ depfinal + 1 ] .cint = mem [ p + 1 ] .cint ; 
    if ( mem [ depfinal ] .hhfield .lhfield == 0 ) 
    goto lab30 ; 
    mem [ depfinal ] .hhfield .v.RH = getnode ( 2 ) ; 
    depfinal = mem [ depfinal ] .hhfield .v.RH ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  lab30: Result = q ; 
  return(Result) ; 
} 
void zlineareq ( p , t ) 
halfword p ; 
smallnumber t ; 
{halfword q, r, s  ; 
  halfword x  ; 
  integer n  ; 
  integer v  ; 
  halfword prevr  ; 
  halfword finalnode  ; 
  integer w  ; 
  q = p ; 
  r = mem [ p ] .hhfield .v.RH ; 
  v = mem [ q + 1 ] .cint ; 
  while ( mem [ r ] .hhfield .lhfield != 0 ) {
      
    if ( abs ( mem [ r + 1 ] .cint ) > abs ( v ) ) 
    {
      q = r ; 
      v = mem [ r + 1 ] .cint ; 
    } 
    r = mem [ r ] .hhfield .v.RH ; 
  } 
  x = mem [ q ] .hhfield .lhfield ; 
  n = mem [ x + 1 ] .cint % 64 ; 
  s = memtop - 1 ; 
  mem [ s ] .hhfield .v.RH = p ; 
  r = p ; 
  do {
      if ( r == q ) 
    {
      mem [ s ] .hhfield .v.RH = mem [ r ] .hhfield .v.RH ; 
      freenode ( r , 2 ) ; 
    } 
    else {
	
      w = makefraction ( mem [ r + 1 ] .cint , v ) ; 
      if ( abs ( w ) <= 1342 ) 
      {
	mem [ s ] .hhfield .v.RH = mem [ r ] .hhfield .v.RH ; 
	freenode ( r , 2 ) ; 
      } 
      else {
	  
	mem [ r + 1 ] .cint = - (integer) w ; 
	s = r ; 
      } 
    } 
    r = mem [ s ] .hhfield .v.RH ; 
  } while ( ! ( mem [ r ] .hhfield .lhfield == 0 ) ) ; 
  if ( t == 18 ) 
  mem [ r + 1 ] .cint = - (integer) makescaled ( mem [ r + 1 ] .cint , v ) ; 
  else if ( v != -268435456L ) 
  mem [ r + 1 ] .cint = - (integer) makefraction ( mem [ r + 1 ] .cint , v ) ; 
  finalnode = r ; 
  p = mem [ memtop - 1 ] .hhfield .v.RH ; 
  if ( internal [ 2 ] > 0 ) 
  if ( interesting ( x ) ) 
  {
    begindiagnostic () ; 
    printnl ( 594 ) ; 
    printvariablename ( x ) ; 
    w = n ; 
    while ( w > 0 ) {
	
      print ( 587 ) ; 
      w = w - 2 ; 
    } 
    printchar ( 61 ) ; 
    printdependency ( p , 17 ) ; 
    enddiagnostic ( false ) ; 
  } 
  prevr = 13 ; 
  r = mem [ 13 ] .hhfield .v.RH ; 
  while ( r != 13 ) {
      
    s = mem [ r + 1 ] .hhfield .v.RH ; 
    q = pwithxbecomingq ( s , x , p , mem [ r ] .hhfield .b0 ) ; 
    if ( mem [ q ] .hhfield .lhfield == 0 ) 
    makeknown ( r , q ) ; 
    else {
	
      mem [ r + 1 ] .hhfield .v.RH = q ; 
      do {
	  q = mem [ q ] .hhfield .v.RH ; 
      } while ( ! ( mem [ q ] .hhfield .lhfield == 0 ) ) ; 
      prevr = q ; 
    } 
    r = mem [ prevr ] .hhfield .v.RH ; 
  } 
  if ( n > 0 ) 
  {
    s = memtop - 1 ; 
    mem [ memtop - 1 ] .hhfield .v.RH = p ; 
    r = p ; 
    do {
	if ( n > 30 ) 
      w = 0 ; 
      else w = mem [ r + 1 ] .cint / twotothe [ n ] ; 
      if ( ( abs ( w ) <= 1342 ) && ( mem [ r ] .hhfield .lhfield != 0 ) ) 
      {
	mem [ s ] .hhfield .v.RH = mem [ r ] .hhfield .v.RH ; 
	freenode ( r , 2 ) ; 
      } 
      else {
	  
	mem [ r + 1 ] .cint = w ; 
	s = r ; 
      } 
      r = mem [ s ] .hhfield .v.RH ; 
    } while ( ! ( mem [ s ] .hhfield .lhfield == 0 ) ) ; 
    p = mem [ memtop - 1 ] .hhfield .v.RH ; 
  } 
  if ( mem [ p ] .hhfield .lhfield == 0 ) 
  {
    mem [ x ] .hhfield .b0 = 16 ; 
    mem [ x + 1 ] .cint = mem [ p + 1 ] .cint ; 
    if ( abs ( mem [ x + 1 ] .cint ) >= 268435456L ) 
    valtoobig ( mem [ x + 1 ] .cint ) ; 
    freenode ( p , 2 ) ; 
    if ( curexp == x ) 
    if ( curtype == 19 ) 
    {
      curexp = mem [ x + 1 ] .cint ; 
      curtype = 16 ; 
      freenode ( x , 2 ) ; 
    } 
  } 
  else {
      
    mem [ x ] .hhfield .b0 = 17 ; 
    depfinal = finalnode ; 
    newdep ( x , p ) ; 
    if ( curexp == x ) 
    if ( curtype == 19 ) 
    curtype = 17 ; 
  } 
  if ( fixneeded ) 
  fixdependencies () ; 
} 
halfword znewringentry ( p ) 
halfword p ; 
{register halfword Result; halfword q  ; 
  q = getnode ( 2 ) ; 
  mem [ q ] .hhfield .b1 = 11 ; 
  mem [ q ] .hhfield .b0 = mem [ p ] .hhfield .b0 ; 
  if ( mem [ p + 1 ] .cint == 0 ) 
  mem [ q + 1 ] .cint = p ; 
  else mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  mem [ p + 1 ] .cint = q ; 
  Result = q ; 
  return(Result) ; 
} 
void znonlineareq ( v , p , flushp ) 
integer v ; 
halfword p ; 
boolean flushp ; 
{smallnumber t  ; 
  halfword q, r  ; 
  t = mem [ p ] .hhfield .b0 - 1 ; 
  q = mem [ p + 1 ] .cint ; 
  if ( flushp ) 
  mem [ p ] .hhfield .b0 = 1 ; 
  else p = q ; 
  do {
      r = mem [ q + 1 ] .cint ; 
    mem [ q ] .hhfield .b0 = t ; 
    switch ( t ) 
    {case 2 : 
      mem [ q + 1 ] .cint = v ; 
      break ; 
    case 4 : 
      {
	mem [ q + 1 ] .cint = v ; 
	{
	  if ( strref [ v ] < 127 ) 
	  incr ( strref [ v ] ) ; 
	} 
      } 
      break ; 
    case 6 : 
      {
	mem [ q + 1 ] .cint = v ; 
	incr ( mem [ v ] .hhfield .lhfield ) ; 
      } 
      break ; 
    case 9 : 
      mem [ q + 1 ] .cint = copypath ( v ) ; 
      break ; 
    case 11 : 
      mem [ q + 1 ] .cint = copyedges ( v ) ; 
      break ; 
    } 
    q = r ; 
  } while ( ! ( q == p ) ) ; 
} 
void zringmerge ( p , q ) 
halfword p ; 
halfword q ; 
{/* 10 */ halfword r  ; 
  r = mem [ p + 1 ] .cint ; 
  while ( r != p ) {
      
    if ( r == q ) 
    {
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 261 ) ; 
	  print ( 597 ) ; 
	} 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 598 ; 
	  helpline [ 0 ] = 599 ; 
	} 
	putgeterror () ; 
      } 
      goto lab10 ; 
    } 
    r = mem [ r + 1 ] .cint ; 
  } 
  r = mem [ p + 1 ] .cint ; 
  mem [ p + 1 ] .cint = mem [ q + 1 ] .cint ; 
  mem [ q + 1 ] .cint = r ; 
  lab10: ; 
} 
void zshowcmdmod ( c , m ) 
integer c ; 
integer m ; 
{begindiagnostic () ; 
  printnl ( 123 ) ; 
  printcmdmod ( c , m ) ; 
  printchar ( 125 ) ; 
  enddiagnostic ( false ) ; 
} 
void showcontext ( ) 
{/* 30 */ schar oldsetting  ; 
  integer i  ; 
  integer l  ; 
  integer m  ; 
  integer n  ; 
  integer p  ; 
  integer q  ; 
  fileptr = inputptr ; 
  inputstack [ fileptr ] = curinput ; 
  while ( true ) {
      
    curinput = inputstack [ fileptr ] ; 
    if ( ( fileptr == inputptr ) || ( curinput .indexfield <= 15 ) || ( 
    curinput .indexfield != 19 ) || ( curinput .locfield != 0 ) ) 
    {
      tally = 0 ; 
      oldsetting = selector ; 
      if ( ( curinput .indexfield <= 15 ) ) 
      {
	if ( curinput .namefield <= 1 ) 
	if ( ( curinput .namefield == 0 ) && ( fileptr == 0 ) ) 
	printnl ( 601 ) ; 
	else printnl ( 602 ) ; 
	else if ( curinput .namefield == 2 ) 
	printnl ( 603 ) ; 
	else {
	    
	  printnl ( 604 ) ; 
	  printint ( line ) ; 
	} 
	printchar ( 32 ) ; 
	{
	  l = tally ; 
	  tally = 0 ; 
	  selector = 4 ; 
	  trickcount = 1000000L ; 
	} 
	if ( curinput .limitfield > 0 ) 
	{register integer for_end; i = curinput .startfield ; for_end = 
	curinput .limitfield - 1 ; if ( i <= for_end) do 
	  {
	    if ( i == curinput .locfield ) 
	    {
	      firstcount = tally ; 
	      trickcount = tally + 1 + errorline - halferrorline ; 
	      if ( trickcount < errorline ) 
	      trickcount = errorline ; 
	    } 
	    print ( buffer [ i ] ) ; 
	  } 
	while ( i++ < for_end ) ; } 
      } 
      else {
	  
	switch ( curinput .indexfield ) 
	{case 16 : 
	  printnl ( 605 ) ; 
	  break ; 
	case 17 : 
	  {
	    printnl ( 610 ) ; 
	    p = paramstack [ curinput .limitfield ] ; 
	    if ( p != 0 ) 
	    if ( mem [ p ] .hhfield .v.RH == 1 ) 
	    printexp ( p , 0 ) ; 
	    else showtokenlist ( p , 0 , 20 , tally ) ; 
	    print ( 611 ) ; 
	  } 
	  break ; 
	case 18 : 
	  printnl ( 606 ) ; 
	  break ; 
	case 19 : 
	  if ( curinput .locfield == 0 ) 
	  printnl ( 607 ) ; 
	  else printnl ( 608 ) ; 
	  break ; 
	case 20 : 
	  printnl ( 609 ) ; 
	  break ; 
	case 21 : 
	  {
	    println () ; 
	    if ( curinput .namefield != 0 ) 
	    slowprint ( hash [ curinput .namefield ] .v.RH ) ; 
	    else {
		
	      p = paramstack [ curinput .limitfield ] ; 
	      if ( p == 0 ) 
	      showtokenlist ( paramstack [ curinput .limitfield + 1 ] , 0 , 20 
	      , tally ) ; 
	      else {
		  
		q = p ; 
		while ( mem [ q ] .hhfield .v.RH != 0 ) q = mem [ q ] .hhfield 
		.v.RH ; 
		mem [ q ] .hhfield .v.RH = paramstack [ curinput .limitfield + 
		1 ] ; 
		showtokenlist ( p , 0 , 20 , tally ) ; 
		mem [ q ] .hhfield .v.RH = 0 ; 
	      } 
	    } 
	    print ( 500 ) ; 
	  } 
	  break ; 
	  default: 
	  printnl ( 63 ) ; 
	  break ; 
	} 
	{
	  l = tally ; 
	  tally = 0 ; 
	  selector = 4 ; 
	  trickcount = 1000000L ; 
	} 
	if ( curinput .indexfield != 21 ) 
	showtokenlist ( curinput .startfield , curinput .locfield , 100000L , 
	0 ) ; 
	else showmacro ( curinput .startfield , curinput .locfield , 100000L ) 
	; 
      } 
      selector = oldsetting ; 
      if ( trickcount == 1000000L ) 
      {
	firstcount = tally ; 
	trickcount = tally + 1 + errorline - halferrorline ; 
	if ( trickcount < errorline ) 
	trickcount = errorline ; 
      } 
      if ( tally < trickcount ) 
      m = tally - firstcount ; 
      else m = trickcount - firstcount ; 
      if ( l + firstcount <= halferrorline ) 
      {
	p = 0 ; 
	n = l + firstcount ; 
      } 
      else {
	  
	print ( 274 ) ; 
	p = l + firstcount - halferrorline + 3 ; 
	n = halferrorline ; 
      } 
      {register integer for_end; q = p ; for_end = firstcount - 1 ; if ( q <= 
      for_end) do 
	printchar ( trickbuf [ q % errorline ] ) ; 
      while ( q++ < for_end ) ; } 
      println () ; 
      {register integer for_end; q = 1 ; for_end = n ; if ( q <= for_end) do 
	printchar ( 32 ) ; 
      while ( q++ < for_end ) ; } 
      if ( m + n <= errorline ) 
      p = firstcount + m ; 
      else p = firstcount + ( errorline - n - 3 ) ; 
      {register integer for_end; q = firstcount ; for_end = p - 1 ; if ( q <= 
      for_end) do 
	printchar ( trickbuf [ q % errorline ] ) ; 
      while ( q++ < for_end ) ; } 
      if ( m + n > errorline ) 
      print ( 274 ) ; 
    } 
    if ( ( curinput .indexfield <= 15 ) ) 
    if ( ( curinput .namefield > 2 ) || ( fileptr == 0 ) ) 
    goto lab30 ; 
    decr ( fileptr ) ; 
  } 
  lab30: curinput = inputstack [ inputptr ] ; 
} 
void zbegintokenlist ( p , t ) 
halfword p ; 
quarterword t ; 
{{
    
    if ( inputptr > maxinstack ) 
    {
      maxinstack = inputptr ; 
      if ( inputptr == stacksize ) 
      overflow ( 612 , stacksize ) ; 
    } 
    inputstack [ inputptr ] = curinput ; 
    incr ( inputptr ) ; 
  } 
  curinput .startfield = p ; 
  curinput .indexfield = t ; 
  curinput .limitfield = paramptr ; 
  curinput .locfield = p ; 
} 
void endtokenlist ( ) 
{/* 30 */ halfword p  ; 
  if ( curinput .indexfield >= 19 ) 
  if ( curinput .indexfield <= 20 ) 
  {
    flushtokenlist ( curinput .startfield ) ; 
    goto lab30 ; 
  } 
  else deletemacref ( curinput .startfield ) ; 
  while ( paramptr > curinput .limitfield ) {
      
    decr ( paramptr ) ; 
    p = paramstack [ paramptr ] ; 
    if ( p != 0 ) 
    if ( mem [ p ] .hhfield .v.RH == 1 ) 
    {
      recyclevalue ( p ) ; 
      freenode ( p , 2 ) ; 
    } 
    else flushtokenlist ( p ) ; 
  } 
  lab30: {
      
    decr ( inputptr ) ; 
    curinput = inputstack [ inputptr ] ; 
  } 
  {
    if ( interrupt != 0 ) 
    pauseforinstructions () ; 
  } 
} 
void zencapsulate ( p ) 
halfword p ; 
{curexp = getnode ( 2 ) ; 
  mem [ curexp ] .hhfield .b0 = curtype ; 
  mem [ curexp ] .hhfield .b1 = 11 ; 
  newdep ( curexp , p ) ; 
} 
void zinstall ( r , q ) 
halfword r ; 
halfword q ; 
{halfword p  ; 
  if ( mem [ q ] .hhfield .b0 == 16 ) 
  {
    mem [ r + 1 ] .cint = mem [ q + 1 ] .cint ; 
    mem [ r ] .hhfield .b0 = 16 ; 
  } 
  else if ( mem [ q ] .hhfield .b0 == 19 ) 
  {
    p = singledependency ( q ) ; 
    if ( p == depfinal ) 
    {
      mem [ r ] .hhfield .b0 = 16 ; 
      mem [ r + 1 ] .cint = 0 ; 
      freenode ( p , 2 ) ; 
    } 
    else {
	
      mem [ r ] .hhfield .b0 = 17 ; 
      newdep ( r , p ) ; 
    } 
  } 
  else {
      
    mem [ r ] .hhfield .b0 = mem [ q ] .hhfield .b0 ; 
    newdep ( r , copydeplist ( mem [ q + 1 ] .hhfield .v.RH ) ) ; 
  } 
} 
void zmakeexpcopy ( p ) 
halfword p ; 
{/* 20 */ halfword q, r, t  ; 
  lab20: curtype = mem [ p ] .hhfield .b0 ; 
  switch ( curtype ) 
  {case 1 : 
  case 2 : 
  case 16 : 
    curexp = mem [ p + 1 ] .cint ; 
    break ; 
  case 3 : 
  case 5 : 
  case 7 : 
  case 12 : 
  case 10 : 
    curexp = newringentry ( p ) ; 
    break ; 
  case 4 : 
    {
      curexp = mem [ p + 1 ] .cint ; 
      {
	if ( strref [ curexp ] < 127 ) 
	incr ( strref [ curexp ] ) ; 
      } 
    } 
    break ; 
  case 6 : 
    {
      curexp = mem [ p + 1 ] .cint ; 
      incr ( mem [ curexp ] .hhfield .lhfield ) ; 
    } 
    break ; 
  case 11 : 
    curexp = copyedges ( mem [ p + 1 ] .cint ) ; 
    break ; 
  case 9 : 
  case 8 : 
    curexp = copypath ( mem [ p + 1 ] .cint ) ; 
    break ; 
  case 13 : 
  case 14 : 
    {
      if ( mem [ p + 1 ] .cint == 0 ) 
      initbignode ( p ) ; 
      t = getnode ( 2 ) ; 
      mem [ t ] .hhfield .b1 = 11 ; 
      mem [ t ] .hhfield .b0 = curtype ; 
      initbignode ( t ) ; 
      q = mem [ p + 1 ] .cint + bignodesize [ curtype ] ; 
      r = mem [ t + 1 ] .cint + bignodesize [ curtype ] ; 
      do {
	  q = q - 2 ; 
	r = r - 2 ; 
	install ( r , q ) ; 
      } while ( ! ( q == mem [ p + 1 ] .cint ) ) ; 
      curexp = t ; 
    } 
    break ; 
  case 17 : 
  case 18 : 
    encapsulate ( copydeplist ( mem [ p + 1 ] .hhfield .v.RH ) ) ; 
    break ; 
  case 15 : 
    {
      {
	mem [ p ] .hhfield .b0 = 19 ; 
	serialno = serialno + 64 ; 
	mem [ p + 1 ] .cint = serialno ; 
      } 
      goto lab20 ; 
    } 
    break ; 
  case 19 : 
    {
      q = singledependency ( p ) ; 
      if ( q == depfinal ) 
      {
	curtype = 16 ; 
	curexp = 0 ; 
	freenode ( q , 2 ) ; 
      } 
      else {
	  
	curtype = 17 ; 
	encapsulate ( q ) ; 
      } 
    } 
    break ; 
    default: 
    confusion ( 797 ) ; 
    break ; 
  } 
} 
halfword curtok ( ) 
{register halfword Result; halfword p  ; 
  smallnumber savetype  ; 
  integer saveexp  ; 
  if ( cursym == 0 ) 
  if ( curcmd == 38 ) 
  {
    savetype = curtype ; 
    saveexp = curexp ; 
    makeexpcopy ( curmod ) ; 
    p = stashcurexp () ; 
    mem [ p ] .hhfield .v.RH = 0 ; 
    curtype = savetype ; 
    curexp = saveexp ; 
  } 
  else {
      
    p = getnode ( 2 ) ; 
    mem [ p + 1 ] .cint = curmod ; 
    mem [ p ] .hhfield .b1 = 12 ; 
    if ( curcmd == 42 ) 
    mem [ p ] .hhfield .b0 = 16 ; 
    else mem [ p ] .hhfield .b0 = 4 ; 
  } 
  else {
      
    {
      p = avail ; 
      if ( p == 0 ) 
      p = getavail () ; 
      else {
	  
	avail = mem [ p ] .hhfield .v.RH ; 
	mem [ p ] .hhfield .v.RH = 0 ; 
	;
#ifdef STAT
	incr ( dynused ) ; 
#endif /* STAT */
      } 
    } 
    mem [ p ] .hhfield .lhfield = cursym ; 
  } 
  Result = p ; 
  return(Result) ; 
} 
void backinput ( ) 
{halfword p  ; 
  p = curtok () ; 
  while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) ) 
  endtokenlist () ; 
  begintokenlist ( p , 19 ) ; 
} 
void backerror ( ) 
{OKtointerrupt = false ; 
  backinput () ; 
  OKtointerrupt = true ; 
  error () ; 
} 
void inserror ( ) 
{OKtointerrupt = false ; 
  backinput () ; 
  curinput .indexfield = 20 ; 
  OKtointerrupt = true ; 
  error () ; 
} 
void beginfilereading ( ) 
{if ( inopen == 15 ) 
  overflow ( 613 , 15 ) ; 
  if ( first == bufsize ) 
  overflow ( 256 , bufsize ) ; 
  incr ( inopen ) ; 
  {
    if ( inputptr > maxinstack ) 
    {
      maxinstack = inputptr ; 
      if ( inputptr == stacksize ) 
      overflow ( 612 , stacksize ) ; 
    } 
    inputstack [ inputptr ] = curinput ; 
    incr ( inputptr ) ; 
  } 
  curinput .indexfield = inopen ; 
  linestack [ curinput .indexfield ] = line ; 
  curinput .startfield = first ; 
  curinput .namefield = 0 ; 
} 
void endfilereading ( ) 
{first = curinput .startfield ; 
  line = linestack [ curinput .indexfield ] ; 
  if ( curinput .indexfield != inopen ) 
  confusion ( 614 ) ; 
  if ( curinput .namefield > 2 ) 
  aclose ( inputfile [ curinput .indexfield ] ) ; 
  {
    decr ( inputptr ) ; 
    curinput = inputstack [ inputptr ] ; 
  } 
  decr ( inopen ) ; 
} 
void clearforerrorprompt ( ) 
{while ( ( curinput .indexfield <= 15 ) && ( curinput .namefield == 0 ) && ( 
  inputptr > 0 ) && ( curinput .locfield == curinput .limitfield ) ) 
  endfilereading () ; 
  println () ; 
} 
boolean checkoutervalidity ( ) 
{register boolean Result; halfword p  ; 
  if ( scannerstatus == 0 ) 
  Result = true ; 
  else {
      
    deletionsallowed = false ; 
    if ( cursym != 0 ) 
    {
      p = getavail () ; 
      mem [ p ] .hhfield .lhfield = cursym ; 
      begintokenlist ( p , 19 ) ; 
    } 
    if ( scannerstatus > 1 ) 
    {
      runaway () ; 
      if ( cursym == 0 ) 
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 261 ) ; 
	print ( 620 ) ; 
      } 
      else {
	  
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 261 ) ; 
	  print ( 621 ) ; 
	} 
      } 
      print ( 622 ) ; 
      {
	helpptr = 4 ; 
	helpline [ 3 ] = 623 ; 
	helpline [ 2 ] = 624 ; 
	helpline [ 1 ] = 625 ; 
	helpline [ 0 ] = 626 ; 
      } 
      switch ( scannerstatus ) 
      {case 2 : 
	{
	  print ( 627 ) ; 
	  helpline [ 3 ] = 628 ; 
	  cursym = 9763 ; 
	} 
	break ; 
      case 3 : 
	{
	  print ( 629 ) ; 
	  helpline [ 3 ] = 630 ; 
	  if ( warninginfo == 0 ) 
	  cursym = 9767 ; 
	  else {
	      
	    cursym = 9759 ; 
	    eqtb [ 9759 ] .v.RH = warninginfo ; 
	  } 
	} 
	break ; 
      case 4 : 
      case 5 : 
	{
	  print ( 631 ) ; 
	  if ( scannerstatus == 5 ) 
	  slowprint ( hash [ warninginfo ] .v.RH ) ; 
	  else printvariablename ( warninginfo ) ; 
	  cursym = 9765 ; 
	} 
	break ; 
      case 6 : 
	{
	  print ( 632 ) ; 
	  slowprint ( hash [ warninginfo ] .v.RH ) ; 
	  print ( 633 ) ; 
	  helpline [ 3 ] = 634 ; 
	  cursym = 9764 ; 
	} 
	break ; 
      } 
      inserror () ; 
    } 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 261 ) ; 
	print ( 615 ) ; 
      } 
      printint ( warninginfo ) ; 
      {
	helpptr = 3 ; 
	helpline [ 2 ] = 616 ; 
	helpline [ 1 ] = 617 ; 
	helpline [ 0 ] = 618 ; 
      } 
      if ( cursym == 0 ) 
      helpline [ 2 ] = 619 ; 
      cursym = 9766 ; 
      inserror () ; 
    } 
    deletionsallowed = true ; 
    Result = false ; 
  } 
  return(Result) ; 
} 
void getnext ( ) 
{/* 20 10 40 25 85 86 87 30 */ integer k  ; 
  ASCIIcode c  ; 
  ASCIIcode class  ; 
  integer n, f  ; 
  lab20: cursym = 0 ; 
  if ( ( curinput .indexfield <= 15 ) ) 
  {
    lab25: c = buffer [ curinput .locfield ] ; 
    incr ( curinput .locfield ) ; 
    class = charclass [ c ] ; 
    switch ( class ) 
    {case 0 : 
      goto lab85 ; 
      break ; 
    case 1 : 
      {
	class = charclass [ buffer [ curinput .locfield ] ] ; 
	if ( class > 1 ) 
	goto lab25 ; 
	else if ( class < 1 ) 
	{
	  n = 0 ; 
	  goto lab86 ; 
	} 
      } 
      break ; 
    case 2 : 
      goto lab25 ; 
      break ; 
    case 3 : 
      {
	if ( curinput .namefield > 2 ) 
	{
	  incr ( line ) ; 
	  first = curinput .startfield ; 
	  if ( ! forceeof ) 
	  {
	    if ( inputln ( inputfile [ curinput .indexfield ] , true ) ) 
	    firmuptheline () ; 
	    else forceeof = true ; 
	  } 
	  if ( forceeof ) 
	  {
	    printchar ( 41 ) ; 
	    decr ( openparens ) ; 
	    flush ( stdout ) ; 
	    forceeof = false ; 
	    endfilereading () ; 
	    if ( checkoutervalidity () ) 
	    goto lab20 ; 
	    else goto lab20 ; 
	  } 
	  buffer [ curinput .limitfield ] = 37 ; 
	  first = curinput .limitfield + 1 ; 
	  curinput .locfield = curinput .startfield ; 
	} 
	else {
	    
	  if ( inputptr > 0 ) 
	  {
	    endfilereading () ; 
	    goto lab20 ; 
	  } 
	  if ( selector < 2 ) 
	  openlogfile () ; 
	  if ( interaction > 1 ) 
	  {
	    if ( curinput .limitfield == curinput .startfield ) 
	    printnl ( 649 ) ; 
	    println () ; 
	    first = curinput .startfield ; 
	    {
	      ; 
	      print ( 42 ) ; 
	      terminput () ; 
	    } 
	    curinput .limitfield = last ; 
	    buffer [ curinput .limitfield ] = 37 ; 
	    first = curinput .limitfield + 1 ; 
	    curinput .locfield = curinput .startfield ; 
	  } 
	  else fatalerror ( 650 ) ; 
	} 
	{
	  if ( interrupt != 0 ) 
	  pauseforinstructions () ; 
	} 
	goto lab25 ; 
      } 
      break ; 
    case 4 : 
      {
	if ( buffer [ curinput .locfield ] == 34 ) 
	curmod = 283 ; 
	else {
	    
	  k = curinput .locfield ; 
	  buffer [ curinput .limitfield + 1 ] = 34 ; 
	  do {
	      incr ( curinput .locfield ) ; 
	  } while ( ! ( buffer [ curinput .locfield ] == 34 ) ) ; 
	  if ( curinput .locfield > curinput .limitfield ) 
	  {
	    curinput .locfield = curinput .limitfield ; 
	    {
	      if ( interaction == 3 ) 
	      ; 
	      printnl ( 261 ) ; 
	      print ( 642 ) ; 
	    } 
	    {
	      helpptr = 3 ; 
	      helpline [ 2 ] = 643 ; 
	      helpline [ 1 ] = 644 ; 
	      helpline [ 0 ] = 645 ; 
	    } 
	    deletionsallowed = false ; 
	    error () ; 
	    deletionsallowed = true ; 
	    goto lab20 ; 
	  } 
	  if ( curinput .locfield == k + 1 ) 
	  curmod = buffer [ k ] ; 
	  else {
	      
	    {
	      if ( poolptr + curinput .locfield - k > maxpoolptr ) 
	      {
		if ( poolptr + curinput .locfield - k > poolsize ) 
		overflow ( 257 , poolsize - initpoolptr ) ; 
		maxpoolptr = poolptr + curinput .locfield - k ; 
	      } 
	    } 
	    do {
		{ 
		strpool [ poolptr ] = buffer [ k ] ; 
		incr ( poolptr ) ; 
	      } 
	      incr ( k ) ; 
	    } while ( ! ( k == curinput .locfield ) ) ; 
	    curmod = makestring () ; 
	  } 
	} 
	incr ( curinput .locfield ) ; 
	curcmd = 39 ; 
	goto lab10 ; 
      } 
      break ; 
    case 5 : 
    case 6 : 
    case 7 : 
    case 8 : 
      {
	k = curinput .locfield - 1 ; 
	goto lab40 ; 
      } 
      break ; 
    case 20 : 
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 261 ) ; 
	  print ( 639 ) ; 
	} 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 640 ; 
	  helpline [ 0 ] = 641 ; 
	} 
	deletionsallowed = false ; 
	error () ; 
	deletionsallowed = true ; 
	goto lab20 ; 
      } 
      break ; 
      default: 
      ; 
      break ; 
    } 
    k = curinput .locfield - 1 ; 
    while ( charclass [ buffer [ curinput .locfield ] ] == class ) incr ( 
    curinput .locfield ) ; 
    goto lab40 ; 
    lab85: n = c - 48 ; 
    while ( charclass [ buffer [ curinput .locfield ] ] == 0 ) {
	
      if ( n < 4096 ) 
      n = 10 * n + buffer [ curinput .locfield ] - 48 ; 
      incr ( curinput .locfield ) ; 
    } 
    if ( buffer [ curinput .locfield ] == 46 ) 
    if ( charclass [ buffer [ curinput .locfield + 1 ] ] == 0 ) 
    goto lab30 ; 
    f = 0 ; 
    goto lab87 ; 
    lab30: incr ( curinput .locfield ) ; 
    lab86: k = 0 ; 
    do {
	if ( k < 17 ) 
      {
	dig [ k ] = buffer [ curinput .locfield ] - 48 ; 
	incr ( k ) ; 
      } 
      incr ( curinput .locfield ) ; 
    } while ( ! ( charclass [ buffer [ curinput .locfield ] ] != 0 ) ) ; 
    f = rounddecimals ( k ) ; 
    if ( f == 65536L ) 
    {
      incr ( n ) ; 
      f = 0 ; 
    } 
    lab87: if ( n < 4096 ) 
    curmod = n * 65536L + f ; 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 261 ) ; 
	print ( 646 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 647 ; 
	helpline [ 0 ] = 648 ; 
      } 
      deletionsallowed = false ; 
      error () ; 
      deletionsallowed = true ; 
      curmod = 268435455L ; 
    } 
    curcmd = 42 ; 
    goto lab10 ; 
    lab40: cursym = idlookup ( k , curinput .locfield - k ) ; 
  } 
  else if ( curinput .locfield >= himemmin ) 
  {
    cursym = mem [ curinput .locfield ] .hhfield .lhfield ; 
    curinput .locfield = mem [ curinput .locfield ] .hhfield .v.RH ; 
    if ( cursym >= 9770 ) 
    if ( cursym >= 9920 ) 
    {
      if ( cursym >= 10070 ) 
      cursym = cursym - 150 ; 
      begintokenlist ( paramstack [ curinput .limitfield + cursym - ( 9920 ) ] 
      , 18 ) ; 
      goto lab20 ; 
    } 
    else {
	
      curcmd = 38 ; 
      curmod = paramstack [ curinput .limitfield + cursym - ( 9770 ) ] ; 
      cursym = 0 ; 
      goto lab10 ; 
    } 
  } 
  else if ( curinput .locfield > 0 ) 
  {
    if ( mem [ curinput .locfield ] .hhfield .b1 == 12 ) 
    {
      curmod = mem [ curinput .locfield + 1 ] .cint ; 
      if ( mem [ curinput .locfield ] .hhfield .b0 == 16 ) 
      curcmd = 42 ; 
      else {
	  
	curcmd = 39 ; 
	{
	  if ( strref [ curmod ] < 127 ) 
	  incr ( strref [ curmod ] ) ; 
	} 
      } 
    } 
    else {
	
      curmod = curinput .locfield ; 
      curcmd = 38 ; 
    } 
    curinput .locfield = mem [ curinput .locfield ] .hhfield .v.RH ; 
    goto lab10 ; 
  } 
  else {
      
    endtokenlist () ; 
    goto lab20 ; 
  } 
  curcmd = eqtb [ cursym ] .lhfield ; 
  curmod = eqtb [ cursym ] .v.RH ; 
  if ( curcmd >= 86 ) 
  if ( checkoutervalidity () ) 
  curcmd = curcmd - 86 ; 
  else goto lab20 ; 
  lab10: ; 
} 
void firmuptheline ( ) 
{integer k  ; 
  curinput .limitfield = last ; 
  if ( internal [ 31 ] > 0 ) 
  if ( interaction > 1 ) 
  {
    ; 
    println () ; 
    if ( curinput .startfield < curinput .limitfield ) 
    {register integer for_end; k = curinput .startfield ; for_end = curinput 
    .limitfield - 1 ; if ( k <= for_end) do 
      print ( buffer [ k ] ) ; 
    while ( k++ < for_end ) ; } 
    first = curinput .limitfield ; 
    {
      ; 
      print ( 651 ) ; 
      terminput () ; 
    } 
    if ( last > first ) 
    {
      {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
      for_end) do 
	buffer [ k + curinput .startfield - first ] = buffer [ k ] ; 
      while ( k++ < for_end ) ; } 
      curinput .limitfield = curinput .startfield + last - first ; 
    } 
  } 
} 
halfword zscantoks ( terminator , substlist , tailend , suffixcount ) 
commandcode terminator ; 
halfword substlist ; 
halfword tailend ; 
smallnumber suffixcount ; 
{/* 30 40 */ register halfword Result; halfword p  ; 
  halfword q  ; 
  integer balance  ; 
  p = memtop - 2 ; 
  balance = 1 ; 
  mem [ memtop - 2 ] .hhfield .v.RH = 0 ; 
  while ( true ) {
      
    getnext () ; 
    if ( cursym > 0 ) 
    {
      {
	q = substlist ; 
	while ( q != 0 ) {
	    
	  if ( mem [ q ] .hhfield .lhfield == cursym ) 
	  {
	    cursym = mem [ q + 1 ] .cint ; 
	    curcmd = 7 ; 
	    goto lab40 ; 
	  } 
	  q = mem [ q ] .hhfield .v.RH ; 
	} 
	lab40: ; 
      } 
      if ( curcmd == terminator ) 
      if ( curmod > 0 ) 
      incr ( balance ) ; 
      else {
	  
	decr ( balance ) ; 
	if ( balance == 0 ) 
	goto lab30 ; 
      } 
      else if ( curcmd == 61 ) 
      {
	if ( curmod == 0 ) 
	getnext () ; 
	else if ( curmod <= suffixcount ) 
	cursym = 9919 + curmod ; 
      } 
    } 
    mem [ p ] .hhfield .v.RH = curtok () ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  lab30: mem [ p ] .hhfield .v.RH = tailend ; 
  flushnodelist ( substlist ) ; 
  Result = mem [ memtop - 2 ] .hhfield .v.RH ; 
  return(Result) ; 
} 
void getsymbol ( ) 
{/* 20 */ lab20: getnext () ; 
  if ( ( cursym == 0 ) || ( cursym > 9757 ) ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 261 ) ; 
      print ( 663 ) ; 
    } 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 664 ; 
      helpline [ 1 ] = 665 ; 
      helpline [ 0 ] = 666 ; 
    } 
    if ( cursym > 0 ) 
    helpline [ 2 ] = 667 ; 
    else if ( curcmd == 39 ) 
    {
      if ( strref [ curmod ] < 127 ) 
      if ( strref [ curmod ] > 1 ) 
      decr ( strref [ curmod ] ) ; 
      else flushstring ( curmod ) ; 
    } 
    cursym = 9757 ; 
    inserror () ; 
    goto lab20 ; 
  } 
} 
void getclearsymbol ( ) 
{getsymbol () ; 
  clearsymbol ( cursym , false ) ; 
} 
void checkequals ( ) 
{if ( curcmd != 51 ) 
  if ( curcmd != 77 ) 
  {
    missingerr ( 61 ) ; 
    {
      helpptr = 5 ; 
      helpline [ 4 ] = 668 ; 
      helpline [ 3 ] = 669 ; 
      helpline [ 2 ] = 670 ; 
      helpline [ 1 ] = 671 ; 
      helpline [ 0 ] = 672 ; 
    } 
    backerror () ; 
  } 
} 
void makeopdef ( ) 
{commandcode m  ; 
  halfword p, q, r  ; 
  m = curmod ; 
  getsymbol () ; 
  q = getnode ( 2 ) ; 
  mem [ q ] .hhfield .lhfield = cursym ; 
  mem [ q + 1 ] .cint = 9770 ; 
  getclearsymbol () ; 
  warninginfo = cursym ; 
  getsymbol () ; 
  p = getnode ( 2 ) ; 
  mem [ p ] .hhfield .lhfield = cursym ; 
  mem [ p + 1 ] .cint = 9771 ; 
  mem [ p ] .hhfield .v.RH = q ; 
  getnext () ; 
  checkequals () ; 
  scannerstatus = 5 ; 
  q = getavail () ; 
  mem [ q ] .hhfield .lhfield = 0 ; 
  r = getavail () ; 
  mem [ q ] .hhfield .v.RH = r ; 
  mem [ r ] .hhfield .lhfield = 0 ; 
  mem [ r ] .hhfield .v.RH = scantoks ( 16 , p , 0 , 0 ) ; 
  scannerstatus = 0 ; 
  eqtb [ warninginfo ] .lhfield = m ; 
  eqtb [ warninginfo ] .v.RH = q ; 
  getxnext () ; 
} 
void zcheckdelimiter ( ldelim , rdelim ) 
halfword ldelim ; 
halfword rdelim ; 
{/* 10 */ if ( curcmd == 62 ) 
  if ( curmod == ldelim ) 
  goto lab10 ; 
  if ( cursym != rdelim ) 
  {
    missingerr ( hash [ rdelim ] .v.RH ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 919 ; 
      helpline [ 0 ] = 920 ; 
    } 
    backerror () ; 
  } 
  else {
      
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 261 ) ; 
      print ( 921 ) ; 
    } 
    slowprint ( hash [ rdelim ] .v.RH ) ; 
    print ( 922 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 923 ; 
      helpline [ 1 ] = 924 ; 
      helpline [ 0 ] = 925 ; 
    } 
    error () ; 
  } 
  lab10: ; 
} 
halfword scandeclaredvariable ( ) 
{/* 30 */ register halfword Result; halfword x  ; 
  halfword h, t  ; 
  halfword l  ; 
  getsymbol () ; 
  x = cursym ; 
  if ( curcmd != 41 ) 
  clearsymbol ( x , false ) ; 
  h = getavail () ; 
  mem [ h ] .hhfield .lhfield = x ; 
  t = h ; 
  while ( true ) {
      
    getxnext () ; 
    if ( cursym == 0 ) 
    goto lab30 ; 
    if ( curcmd != 41 ) 
    if ( curcmd != 40 ) 
    if ( curcmd == 63 ) 
    {
      l = cursym ; 
      getxnext () ; 
      if ( curcmd != 64 ) 
      {
	backinput () ; 
	cursym = l ; 
	curcmd = 63 ; 
	goto lab30 ; 
      } 
      else cursym = 0 ; 
    } 
    else goto lab30 ; 
    mem [ t ] .hhfield .v.RH = getavail () ; 
    t = mem [ t ] .hhfield .v.RH ; 
    mem [ t ] .hhfield .lhfield = cursym ; 
  } 
  lab30: if ( eqtb [ x ] .lhfield != 41 ) 
  clearsymbol ( x , false ) ; 
  if ( eqtb [ x ] .v.RH == 0 ) 
  newroot ( x ) ; 
  Result = h ; 
  return(Result) ; 
} 
void scandef ( ) 
{schar m  ; 
  schar n  ; 
  unsigned char k  ; 
  schar c  ; 
  halfword r  ; 
  halfword q  ; 
  halfword p  ; 
  halfword base  ; 
  halfword ldelim, rdelim  ; 
  m = curmod ; 
  c = 0 ; 
  mem [ memtop - 2 ] .hhfield .v.RH = 0 ; 
  q = getavail () ; 
  mem [ q ] .hhfield .lhfield = 0 ; 
  r = 0 ; 
  if ( m == 1 ) 
  {
    getclearsymbol () ; 
    warninginfo = cursym ; 
    getnext () ; 
    scannerstatus = 5 ; 
    n = 0 ; 
    eqtb [ warninginfo ] .lhfield = 10 ; 
    eqtb [ warninginfo ] .v.RH = q ; 
  } 
  else {
      
    p = scandeclaredvariable () ; 
    flushvariable ( eqtb [ mem [ p ] .hhfield .lhfield ] .v.RH , mem [ p ] 
    .hhfield .v.RH , true ) ; 
    warninginfo = findvariable ( p ) ; 
    flushlist ( p ) ; 
    if ( warninginfo == 0 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 261 ) ; 
	print ( 679 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 680 ; 
	helpline [ 0 ] = 681 ; 
      } 
      error () ; 
      warninginfo = 21 ; 
    } 
    scannerstatus = 4 ; 
    n = 2 ; 
    if ( curcmd == 61 ) 
    if ( curmod == 3 ) 
    {
      n = 3 ; 
      getnext () ; 
    } 
    mem [ warninginfo ] .hhfield .b0 = 20 + n ; 
    mem [ warninginfo + 1 ] .cint = q ; 
  } 
  k = n ; 
  if ( curcmd == 31 ) 
  do {
      ldelim = cursym ; 
    rdelim = curmod ; 
    getnext () ; 
    if ( ( curcmd == 56 ) && ( curmod >= 9770 ) ) 
    base = curmod ; 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 261 ) ; 
	print ( 682 ) ; 
      } 
      {
	helpptr = 1 ; 
	helpline [ 0 ] = 683 ; 
      } 
      backerror () ; 
      base = 9770 ; 
    } 
    do {
	mem [ q ] .hhfield .v.RH = getavail () ; 
      q = mem [ q ] .hhfield .v.RH ; 
      mem [ q ] .hhfield .lhfield = base + k ; 
      getsymbol () ; 
      p = getnode ( 2 ) ; 
      mem [ p + 1 ] .cint = base + k ; 
      mem [ p ] .hhfield .lhfield = cursym ; 
      if ( k == 150 ) 
      overflow ( 684 , 150 ) ; 
      incr ( k ) ; 
      mem [ p ] .hhfield .v.RH = r ; 
      r = p ; 
      getnext () ; 
    } while ( ! ( curcmd != 82 ) ) ; 
    checkdelimiter ( ldelim , rdelim ) ; 
    getnext () ; 
  } while ( ! ( curcmd != 31 ) ) ; 
  if ( curcmd == 56 ) 
  {
    p = getnode ( 2 ) ; 
    if ( curmod < 9770 ) 
    {
      c = curmod ; 
      mem [ p + 1 ] .cint = 9770 + k ; 
    } 
    else {
	
      mem [ p + 1 ] .cint = curmod + k ; 
      if ( curmod == 9770 ) 
      c = 4 ; 
      else if ( curmod == 9920 ) 
      c = 6 ; 
      else c = 7 ; 
    } 
    if ( k == 150 ) 
    overflow ( 684 , 150 ) ; 
    incr ( k ) ; 
    getsymbol () ; 
    mem [ p ] .hhfield .lhfield = cursym ; 
    mem [ p ] .hhfield .v.RH = r ; 
    r = p ; 
    getnext () ; 
    if ( c == 4 ) 
    if ( curcmd == 69 ) 
    {
      c = 5 ; 
      p = getnode ( 2 ) ; 
      if ( k == 150 ) 
      overflow ( 684 , 150 ) ; 
      mem [ p + 1 ] .cint = 9770 + k ; 
      getsymbol () ; 
      mem [ p ] .hhfield .lhfield = cursym ; 
      mem [ p ] .hhfield .v.RH = r ; 
      r = p ; 
      getnext () ; 
    } 
  } 
  checkequals () ; 
  p = getavail () ; 
  mem [ p ] .hhfield .lhfield = c ; 
  mem [ q ] .hhfield .v.RH = p ; 
  if ( m == 1 ) 
  mem [ p ] .hhfield .v.RH = scantoks ( 16 , r , 0 , n ) ; 
  else {
      
    q = getavail () ; 
    mem [ q ] .hhfield .lhfield = bgloc ; 
    mem [ p ] .hhfield .v.RH = q ; 
    p = getavail () ; 
    mem [ p ] .hhfield .lhfield = egloc ; 
    mem [ q ] .hhfield .v.RH = scantoks ( 16 , r , p , n ) ; 
  } 
  if ( warninginfo == 21 ) 
  flushtokenlist ( mem [ 22 ] .cint ) ; 
  scannerstatus = 0 ; 
  getxnext () ; 
} 
void zprintmacroname ( a , n ) 
halfword a ; 
halfword n ; 
{halfword p, q  ; 
  if ( n != 0 ) 
  slowprint ( hash [ n ] .v.RH ) ; 
  else {
      
    p = mem [ a ] .hhfield .lhfield ; 
    if ( p == 0 ) 
    slowprint ( hash [ mem [ mem [ mem [ a ] .hhfield .v.RH ] .hhfield 
    .lhfield ] .hhfield .lhfield ] .v.RH ) ; 
    else {
	
      q = p ; 
      while ( mem [ q ] .hhfield .v.RH != 0 ) q = mem [ q ] .hhfield .v.RH ; 
      mem [ q ] .hhfield .v.RH = mem [ mem [ a ] .hhfield .v.RH ] .hhfield 
      .lhfield ; 
      showtokenlist ( p , 0 , 1000 , 0 ) ; 
      mem [ q ] .hhfield .v.RH = 0 ; 
    } 
  } 
} 
void zprintarg ( q , n , b ) 
halfword q ; 
integer n ; 
halfword b ; 
{if ( mem [ q ] .hhfield .v.RH == 1 ) 
  printnl ( 497 ) ; 
  else if ( ( b < 10070 ) && ( b != 7 ) ) 
  printnl ( 498 ) ; 
  else printnl ( 499 ) ; 
  printint ( n ) ; 
  print ( 700 ) ; 
  if ( mem [ q ] .hhfield .v.RH == 1 ) 
  printexp ( q , 1 ) ; 
  else showtokenlist ( q , 0 , 1000 , 0 ) ; 
} 
void zscantextarg ( ldelim , rdelim ) 
halfword ldelim ; 
halfword rdelim ; 
{/* 30 */ integer balance  ; 
  halfword p  ; 
  warninginfo = ldelim ; 
  scannerstatus = 3 ; 
  p = memtop - 2 ; 
  balance = 1 ; 
  mem [ memtop - 2 ] .hhfield .v.RH = 0 ; 
  while ( true ) {
      
    getnext () ; 
    if ( ldelim == 0 ) 
    {
      if ( curcmd > 82 ) 
      {
	if ( balance == 1 ) 
	goto lab30 ; 
	else if ( curcmd == 84 ) 
	decr ( balance ) ; 
      } 
      else if ( curcmd == 32 ) 
      incr ( balance ) ; 
    } 
    else {
	
      if ( curcmd == 62 ) 
      {
	if ( curmod == ldelim ) 
	{
	  decr ( balance ) ; 
	  if ( balance == 0 ) 
	  goto lab30 ; 
	} 
      } 
      else if ( curcmd == 31 ) 
      if ( curmod == rdelim ) 
      incr ( balance ) ; 
    } 
    mem [ p ] .hhfield .v.RH = curtok () ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  lab30: curexp = mem [ memtop - 2 ] .hhfield .v.RH ; 
  curtype = 20 ; 
  scannerstatus = 0 ; 
}