#define EXTERN extern
#include "mpd.h"

halfword curtok ( ) 
{register halfword Result; halfword p  ; 
  smallnumber savetype  ; 
  integer saveexp  ; 
  if ( cursym == 0 ) 
  if ( curcmd == 40 ) 
  {
    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 = 15 ; 
    if ( curcmd == 44 ) 
    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 ( 628 , 15 ) ; 
  if ( first == bufsize ) 
  overflow ( 256 , bufsize ) ; 
  incr ( inopen ) ; 
  {
    if ( inputptr > maxinstack ) 
    {
      maxinstack = inputptr ; 
      if ( inputptr == stacksize ) 
      overflow ( 627 , stacksize ) ; 
    } 
    inputstack [ inputptr ] = curinput ; 
    incr ( inputptr ) ; 
  } 
  curinput .indexfield = inopen ; 
  mpxname [ curinput .indexfield ] = 1 ; 
  curinput .startfield = first ; 
  curinput .namefield = 0 ; 
} 
void endfilereading ( ) 
{if ( inopen > curinput .indexfield ) 
  if ( ( mpxname [ inopen ] == 1 ) || ( curinput .namefield <= 2 ) ) 
  confusion ( 629 ) ; 
  else {
      
    aclose ( inputfile [ inopen ] ) ; 
    {
      if ( strref [ mpxname [ inopen ] ] < 127 ) 
      if ( strref [ mpxname [ inopen ] ] > 1 ) 
      decr ( strref [ mpxname [ inopen ] ] ) ; 
      else flushstring ( mpxname [ inopen ] ) ; 
    } 
    decr ( inopen ) ; 
  } 
  first = curinput .startfield ; 
  if ( curinput .indexfield != inopen ) 
  confusion ( 629 ) ; 
  if ( curinput .namefield > 2 ) 
  {
    aclose ( inputfile [ curinput .indexfield ] ) ; 
    {
      if ( strref [ curinput .namefield ] < 127 ) 
      if ( strref [ curinput .namefield ] > 1 ) 
      decr ( strref [ curinput .namefield ] ) ; 
      else flushstring ( curinput .namefield ) ; 
    } 
    {
      if ( strref [ inamestack [ curinput .indexfield ] ] < 127 ) 
      if ( strref [ inamestack [ curinput .indexfield ] ] > 1 ) 
      decr ( strref [ inamestack [ curinput .indexfield ] ] ) ; 
      else flushstring ( inamestack [ curinput .indexfield ] ) ; 
    } 
    {
      if ( strref [ iareastack [ curinput .indexfield ] ] < 127 ) 
      if ( strref [ iareastack [ curinput .indexfield ] ] > 1 ) 
      decr ( strref [ iareastack [ curinput .indexfield ] ] ) ; 
      else flushstring ( iareastack [ curinput .indexfield ] ) ; 
    } 
  } 
  {
    decr ( inputptr ) ; 
    curinput = inputstack [ inputptr ] ; 
  } 
  decr ( inopen ) ; 
} 
boolean beginmpxreading ( ) 
{register boolean Result; if ( inopen != curinput .indexfield + 1 ) 
  Result = false ; 
  else {
      
    if ( mpxname [ inopen ] <= 1 ) 
    confusion ( 630 ) ; 
    if ( first == bufsize ) 
    overflow ( 256 , bufsize ) ; 
    {
      if ( inputptr > maxinstack ) 
      {
	maxinstack = inputptr ; 
	if ( inputptr == stacksize ) 
	overflow ( 627 , stacksize ) ; 
      } 
      inputstack [ inputptr ] = curinput ; 
      incr ( inputptr ) ; 
    } 
    curinput .indexfield = inopen ; 
    curinput .startfield = first ; 
    curinput .namefield = mpxname [ inopen ] ; 
    {
      if ( strref [ curinput .namefield ] < 127 ) 
      incr ( strref [ curinput .namefield ] ) ; 
    } 
    last = first ; 
    curinput .limitfield = last ; 
    buffer [ curinput .limitfield ] = 37 ; 
    first = curinput .limitfield + 1 ; 
    curinput .locfield = curinput .startfield ; 
    Result = true ; 
  } 
  return(Result) ; 
} 
void endmpxreading ( ) 
{if ( inopen != curinput .indexfield ) 
  confusion ( 630 ) ; 
  if ( curinput .locfield < curinput .limitfield ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 631 ) ; 
    } 
    {
      helpptr = 4 ; 
      helpline [ 3 ] = 632 ; 
      helpline [ 2 ] = 633 ; 
      helpline [ 1 ] = 634 ; 
      helpline [ 0 ] = 635 ; 
    } 
    error () ; 
  } 
  first = curinput .startfield ; 
  {
    decr ( inputptr ) ; 
    curinput = inputstack [ inputptr ] ; 
  } 
} 
void clearforerrorprompt ( ) 
{while ( ( curinput .indexfield <= 15 ) && ( curinput .namefield == 0 ) && ( 
  inputptr > 0 ) && ( curinput .locfield == curinput .limitfield ) ) 
  endfilereading () ; 
  println () ; 
  flush ( termin ) ; 
} 
boolean checkoutervalidity ( ) 
{register boolean Result; halfword p  ; 
  if ( scannerstatus == 0 ) 
  Result = true ; 
  else if ( scannerstatus == 7 ) 
  if ( cursym != 0 ) 
  Result = true ; 
  else {
      
    deletionsallowed = false ; 
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 641 ) ; 
    } 
    printint ( warninginfo ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 642 ; 
      helpline [ 0 ] = 643 ; 
    } 
    cursym = 2368 ; 
    inserror () ; 
    deletionsallowed = true ; 
    Result = false ; 
  } 
  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 ( 263 ) ; 
	print ( 644 ) ; 
      } 
      else {
	  
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 645 ) ; 
	} 
      } 
      print ( 646 ) ; 
      {
	helpptr = 4 ; 
	helpline [ 3 ] = 647 ; 
	helpline [ 2 ] = 648 ; 
	helpline [ 1 ] = 649 ; 
	helpline [ 0 ] = 650 ; 
      } 
      switch ( scannerstatus ) 
      {case 2 : 
	{
	  print ( 651 ) ; 
	  helpline [ 3 ] = 652 ; 
	  cursym = 2363 ; 
	} 
	break ; 
      case 3 : 
	{
	  print ( 653 ) ; 
	  helpline [ 3 ] = 654 ; 
	  if ( warninginfo == 0 ) 
	  cursym = 2367 ; 
	  else {
	      
	    cursym = 2359 ; 
	    eqtb [ 2359 ] .v.RH = warninginfo ; 
	  } 
	} 
	break ; 
      case 4 : 
      case 5 : 
	{
	  print ( 655 ) ; 
	  if ( scannerstatus == 5 ) 
	  print ( hash [ warninginfo ] .v.RH ) ; 
	  else printvariablename ( warninginfo ) ; 
	  cursym = 2365 ; 
	} 
	break ; 
      case 6 : 
	{
	  print ( 656 ) ; 
	  print ( hash [ warninginfo ] .v.RH ) ; 
	  print ( 657 ) ; 
	  helpline [ 3 ] = 658 ; 
	  cursym = 2364 ; 
	} 
	break ; 
      } 
      inserror () ; 
    } 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 636 ) ; 
      } 
      printint ( warninginfo ) ; 
      {
	helpptr = 3 ; 
	helpline [ 2 ] = 637 ; 
	helpline [ 1 ] = 638 ; 
	helpline [ 0 ] = 639 ; 
      } 
      if ( cursym == 0 ) 
      helpline [ 2 ] = 640 ; 
      cursym = 2366 ; 
      inserror () ; 
    } 
    deletionsallowed = true ; 
    Result = false ; 
  } 
  return(Result) ; 
} 
void getnext ( ) 
{/* 20 10 50 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 ( scannerstatus == 7 ) 
	if ( curinput .locfield < curinput .limitfield ) 
	goto lab25 ; 
	if ( curinput .namefield > 2 ) 
	{
	  incr ( linestack [ curinput .indexfield ] ) ; 
	  first = curinput .startfield ; 
	  if ( ! forceeof ) 
	  {
	    if ( inputln ( inputfile [ curinput .indexfield ] , true ) ) 
	    firmuptheline () ; 
	    else forceeof = true ; 
	  } 
	  if ( forceeof ) 
	  {
	    forceeof = false ; 
	    decr ( curinput .locfield ) ; 
	    if ( ( mpxname [ curinput .indexfield ] > 1 ) ) 
	    {
	      mpxname [ curinput .indexfield ] = 0 ; 
	      {
		if ( interaction == 3 ) 
		; 
		printnl ( 263 ) ; 
		print ( 677 ) ; 
	      } 
	      {
		helpptr = 4 ; 
		helpline [ 3 ] = 678 ; 
		helpline [ 2 ] = 633 ; 
		helpline [ 1 ] = 679 ; 
		helpline [ 0 ] = 680 ; 
	      } 
	      deletionsallowed = false ; 
	      error () ; 
	      deletionsallowed = true ; 
	      cursym = 2369 ; 
	      goto lab50 ; 
	    } 
	    else {
		
	      printchar ( 41 ) ; 
	      decr ( openparens ) ; 
	      flush ( termout ) ; 
	      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 < 6 ) 
	  openlogfile () ; 
	  if ( interaction > 1 ) 
	  {
	    if ( curinput .limitfield == curinput .startfield ) 
	    printnl ( 675 ) ; 
	    println () ; 
	    first = curinput .startfield ; 
	    {
	      ; 
	      print ( 42 ) ; 
	      terminput () ; 
	    } 
	    curinput .limitfield = last ; 
	    buffer [ curinput .limitfield ] = 37 ; 
	    first = curinput .limitfield + 1 ; 
	    curinput .locfield = curinput .startfield ; 
	  } 
	  else fatalerror ( 676 ) ; 
	} 
	{
	  if ( interrupt != 0 ) 
	  pauseforinstructions () ; 
	} 
	goto lab25 ; 
      } 
      break ; 
    case 4 : 
      if ( scannerstatus == 7 ) 
      goto lab25 ; 
      else {
	  
	if ( buffer [ curinput .locfield ] == 34 ) 
	curmod = 285 ; 
	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 ( 263 ) ; 
	      print ( 666 ) ; 
	    } 
	    {
	      helpptr = 3 ; 
	      helpline [ 2 ] = 667 ; 
	      helpline [ 1 ] = 668 ; 
	      helpline [ 0 ] = 669 ; 
	    } 
	    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 ) 
	      docompaction ( curinput .locfield - k ) ; 
	      else maxpoolptr = poolptr + curinput .locfield - k ; 
	    } 
	    do {
		{ 
		strpool [ poolptr ] = buffer [ k ] ; 
		incr ( poolptr ) ; 
	      } 
	      incr ( k ) ; 
	    } while ( ! ( k == curinput .locfield ) ) ; 
	    curmod = makestring () ; 
	  } 
	} 
	incr ( curinput .locfield ) ; 
	curcmd = 41 ; 
	goto lab10 ; 
      } 
      break ; 
    case 5 : 
    case 6 : 
    case 7 : 
    case 8 : 
      {
	k = curinput .locfield - 1 ; 
	goto lab40 ; 
      } 
      break ; 
    case 20 : 
      if ( scannerstatus == 7 ) 
      goto lab25 ; 
      else {
	  
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 663 ) ; 
	} 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 664 ; 
	  helpline [ 0 ] = 665 ; 
	} 
	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 < 32768L ) 
      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 < 32768L ) 
    {
      curmod = n * 65536L + f ; 
      if ( curmod >= 268435456L ) 
      if ( internal [ 30 ] > 0 ) 
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 673 ) ; 
	} 
	printscaled ( curmod ) ; 
	printchar ( 41 ) ; 
	{
	  helpptr = 3 ; 
	  helpline [ 2 ] = 674 ; 
	  helpline [ 1 ] = 605 ; 
	  helpline [ 0 ] = 606 ; 
	} 
	error () ; 
      } 
    } 
    else if ( scannerstatus != 7 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 670 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 671 ; 
	helpline [ 0 ] = 672 ; 
      } 
      deletionsallowed = false ; 
      error () ; 
      deletionsallowed = true ; 
      curmod = 2147483647L ; 
    } 
    curcmd = 44 ; 
    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 >= 2372 ) 
    if ( cursym >= 2522 ) 
    {
      if ( cursym >= 2672 ) 
      cursym = cursym - 150 ; 
      begintokenlist ( paramstack [ curinput .limitfield + cursym - ( 2522 ) ] 
      , 18 ) ; 
      goto lab20 ; 
    } 
    else {
	
      curcmd = 40 ; 
      curmod = paramstack [ curinput .limitfield + cursym - ( 2372 ) ] ; 
      cursym = 0 ; 
      goto lab10 ; 
    } 
  } 
  else if ( curinput .locfield > 0 ) 
  {
    if ( mem [ curinput .locfield ] .hhfield .b1 == 15 ) 
    {
      curmod = mem [ curinput .locfield + 1 ] .cint ; 
      if ( mem [ curinput .locfield ] .hhfield .b0 == 16 ) 
      curcmd = 44 ; 
      else {
	  
	curcmd = 41 ; 
	{
	  if ( strref [ curmod ] < 127 ) 
	  incr ( strref [ curmod ] ) ; 
	} 
      } 
    } 
    else {
	
      curmod = curinput .locfield ; 
      curcmd = 40 ; 
    } 
    curinput .locfield = mem [ curinput .locfield ] .hhfield .v.RH ; 
    goto lab10 ; 
  } 
  else {
      
    endtokenlist () ; 
    goto lab20 ; 
  } 
  lab50: curcmd = eqtb [ cursym ] .lhfield ; 
  curmod = eqtb [ cursym ] .v.RH ; 
  if ( curcmd >= 85 ) 
  if ( checkoutervalidity () ) 
  curcmd = curcmd - 85 ; 
  else goto lab20 ; 
  lab10: ; 
} 
void firmuptheline ( ) 
{integer k  ; 
  curinput .limitfield = last ; 
  if ( internal [ 24 ] > 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 ( 681 ) ; 
      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 ; 
    } 
  } 
} 
void tnext ( ) 
{/* 65 50 */ char oldstatus  ; 
  integer oldinfo  ; 
  while ( curcmd <= 3 ) {
      
    if ( curcmd == 3 ) 
    if ( ! ( curinput .indexfield <= 15 ) || ( mpxname [ curinput .indexfield 
    ] == 1 ) ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 691 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 692 ; 
	helpline [ 0 ] = 693 ; 
      } 
      error () ; 
    } 
    else {
	
      endmpxreading () ; 
      goto lab65 ; 
    } 
    else if ( curcmd == 1 ) 
    if ( ( curinput .indexfield > 15 ) || ( curinput .namefield <= 2 ) ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 687 ) ; 
      } 
      {
	helpptr = 3 ; 
	helpline [ 2 ] = 688 ; 
	helpline [ 1 ] = 689 ; 
	helpline [ 0 ] = 690 ; 
      } 
      error () ; 
    } 
    else if ( ( mpxname [ curinput .indexfield ] > 1 ) ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 684 ) ; 
      } 
      {
	helpptr = 4 ; 
	helpline [ 3 ] = 632 ; 
	helpline [ 2 ] = 633 ; 
	helpline [ 1 ] = 685 ; 
	helpline [ 0 ] = 686 ; 
      } 
      error () ; 
    } 
    else if ( ( curmod != 1 ) && ( mpxname [ curinput .indexfield ] != 0 ) ) 
    {
      if ( ! beginmpxreading () ) 
      startmpxinput () ; 
    } 
    else goto lab65 ; 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 694 ) ; 
      } 
      {
	helpptr = 1 ; 
	helpline [ 0 ] = 695 ; 
      } 
      error () ; 
    } 
    goto lab50 ; 
    lab65: oldstatus = scannerstatus ; 
    oldinfo = warninginfo ; 
    scannerstatus = 7 ; 
    warninginfo = linestack [ curinput .indexfield ] ; 
    do {
	getnext () ; 
    } while ( ! ( curcmd == 2 ) ) ; 
    scannerstatus = oldstatus ; 
    warninginfo = oldinfo ; 
    lab50: getnext () ; 
  } 
} 
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 ( curcmd <= 3 ) 
      tnext () ; 
    } 
    if ( cursym > 0 ) 
    {
      {
	q = substlist ; 
	while ( q != 0 ) {
	    
	  if ( mem [ q ] .hhfield .lhfield == cursym ) 
	  {
	    cursym = mem [ q + 1 ] .cint ; 
	    curcmd = 10 ; 
	    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 == 63 ) 
      {
	if ( curmod == 0 ) 
	{
	  getnext () ; 
	  if ( curcmd <= 3 ) 
	  tnext () ; 
	} 
	else if ( curmod <= suffixcount ) 
	cursym = 2521 + 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 ( curcmd <= 3 ) 
    tnext () ; 
  } 
  if ( ( cursym == 0 ) || ( cursym > 2357 ) ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 707 ) ; 
    } 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 708 ; 
      helpline [ 1 ] = 709 ; 
      helpline [ 0 ] = 710 ; 
    } 
    if ( cursym > 0 ) 
    helpline [ 2 ] = 711 ; 
    else if ( curcmd == 41 ) 
    {
      if ( strref [ curmod ] < 127 ) 
      if ( strref [ curmod ] > 1 ) 
      decr ( strref [ curmod ] ) ; 
      else flushstring ( curmod ) ; 
    } 
    cursym = 2357 ; 
    inserror () ; 
    goto lab20 ; 
  } 
} 
void getclearsymbol ( ) 
{getsymbol () ; 
  clearsymbol ( cursym , false ) ; 
} 
void checkequals ( ) 
{if ( curcmd != 53 ) 
  if ( curcmd != 76 ) 
  {
    missingerr ( 61 ) ; 
    {
      helpptr = 5 ; 
      helpline [ 4 ] = 712 ; 
      helpline [ 3 ] = 713 ; 
      helpline [ 2 ] = 714 ; 
      helpline [ 1 ] = 715 ; 
      helpline [ 0 ] = 716 ; 
    } 
    backerror () ; 
  } 
} 
void makeopdef ( ) 
{commandcode m  ; 
  halfword p, q, r  ; 
  m = curmod ; 
  getsymbol () ; 
  q = getnode ( 2 ) ; 
  mem [ q ] .hhfield .lhfield = cursym ; 
  mem [ q + 1 ] .cint = 2372 ; 
  getclearsymbol () ; 
  warninginfo = cursym ; 
  getsymbol () ; 
  p = getnode ( 2 ) ; 
  mem [ p ] .hhfield .lhfield = cursym ; 
  mem [ p + 1 ] .cint = 2373 ; 
  mem [ p ] .hhfield .v.RH = q ; 
  {
    getnext () ; 
    if ( curcmd <= 3 ) 
    tnext () ; 
  } 
  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 ( 18 , 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 == 64 ) 
  if ( curmod == ldelim ) 
  goto lab10 ; 
  if ( cursym != rdelim ) 
  {
    missingerr ( hash [ rdelim ] .v.RH ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 970 ; 
      helpline [ 0 ] = 971 ; 
    } 
    backerror () ; 
  } 
  else {
      
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 972 ) ; 
    } 
    print ( hash [ rdelim ] .v.RH ) ; 
    print ( 973 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 974 ; 
      helpline [ 1 ] = 975 ; 
      helpline [ 0 ] = 976 ; 
    } 
    error () ; 
  } 
  lab10: ; 
} 
halfword scandeclaredvariable ( ) 
{/* 30 */ register halfword Result; halfword x  ; 
  halfword h, t  ; 
  halfword l  ; 
  getsymbol () ; 
  x = cursym ; 
  if ( curcmd != 43 ) 
  clearsymbol ( x , false ) ; 
  h = getavail () ; 
  mem [ h ] .hhfield .lhfield = x ; 
  t = h ; 
  while ( true ) {
      
    getxnext () ; 
    if ( cursym == 0 ) 
    goto lab30 ; 
    if ( curcmd != 43 ) 
    if ( curcmd != 42 ) 
    if ( curcmd == 65 ) 
    {
      l = cursym ; 
      getxnext () ; 
      if ( curcmd != 66 ) 
      {
	backinput () ; 
	cursym = l ; 
	curcmd = 65 ; 
	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 != 43 ) 
  clearsymbol ( x , false ) ; 
  if ( eqtb [ x ] .v.RH == 0 ) 
  newroot ( x ) ; 
  Result = h ; 
  return(Result) ; 
} 
void scandef ( ) 
{char m  ; 
  char n  ; 
  unsigned char k  ; 
  char 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 () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
    scannerstatus = 5 ; 
    n = 0 ; 
    eqtb [ warninginfo ] .lhfield = 13 ; 
    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 ( 263 ) ; 
	print ( 723 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 724 ; 
	helpline [ 0 ] = 725 ; 
      } 
      error () ; 
      warninginfo = 22 ; 
    } 
    scannerstatus = 4 ; 
    n = 2 ; 
    if ( curcmd == 63 ) 
    if ( curmod == 3 ) 
    {
      n = 3 ; 
      {
	getnext () ; 
	if ( curcmd <= 3 ) 
	tnext () ; 
      } 
    } 
    mem [ warninginfo ] .hhfield .b0 = 20 + n ; 
    mem [ warninginfo + 1 ] .cint = q ; 
  } 
  k = n ; 
  if ( curcmd == 33 ) 
  do {
      ldelim = cursym ; 
    rdelim = curmod ; 
    {
      getnext () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
    if ( ( curcmd == 58 ) && ( curmod >= 2372 ) ) 
    base = curmod ; 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 726 ) ; 
      } 
      {
	helpptr = 1 ; 
	helpline [ 0 ] = 727 ; 
      } 
      backerror () ; 
      base = 2372 ; 
    } 
    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 ( 728 , 150 ) ; 
      incr ( k ) ; 
      mem [ p ] .hhfield .v.RH = r ; 
      r = p ; 
      {
	getnext () ; 
	if ( curcmd <= 3 ) 
	tnext () ; 
      } 
    } while ( ! ( curcmd != 81 ) ) ; 
    checkdelimiter ( ldelim , rdelim ) ; 
    {
      getnext () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
  } while ( ! ( curcmd != 33 ) ) ; 
  if ( curcmd == 58 ) 
  {
    p = getnode ( 2 ) ; 
    if ( curmod < 2372 ) 
    {
      c = curmod ; 
      mem [ p + 1 ] .cint = 2372 + k ; 
    } 
    else {
	
      mem [ p + 1 ] .cint = curmod + k ; 
      if ( curmod == 2372 ) 
      c = 4 ; 
      else if ( curmod == 2522 ) 
      c = 6 ; 
      else c = 7 ; 
    } 
    if ( k == 150 ) 
    overflow ( 728 , 150 ) ; 
    incr ( k ) ; 
    getsymbol () ; 
    mem [ p ] .hhfield .lhfield = cursym ; 
    mem [ p ] .hhfield .v.RH = r ; 
    r = p ; 
    {
      getnext () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
    if ( c == 4 ) 
    if ( curcmd == 70 ) 
    {
      c = 5 ; 
      p = getnode ( 2 ) ; 
      if ( k == 150 ) 
      overflow ( 728 , 150 ) ; 
      mem [ p + 1 ] .cint = 2372 + k ; 
      getsymbol () ; 
      mem [ p ] .hhfield .lhfield = cursym ; 
      mem [ p ] .hhfield .v.RH = r ; 
      r = p ; 
      {
	getnext () ; 
	if ( curcmd <= 3 ) 
	tnext () ; 
      } 
    } 
  } 
  checkequals () ; 
  p = getavail () ; 
  mem [ p ] .hhfield .lhfield = c ; 
  mem [ q ] .hhfield .v.RH = p ; 
  if ( m == 1 ) 
  mem [ p ] .hhfield .v.RH = scantoks ( 18 , 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 ( 18 , r , p , n ) ; 
  } 
  if ( warninginfo == 22 ) 
  flushtokenlist ( mem [ 23 ] .cint ) ; 
  scannerstatus = 0 ; 
  getxnext () ; 
} 
void zprintmacroname ( a , n ) 
halfword a ; 
halfword n ; 
{halfword p, q  ; 
  if ( n != 0 ) 
  print ( hash [ n ] .v.RH ) ; 
  else {
      
    p = mem [ a ] .hhfield .lhfield ; 
    if ( p == 0 ) 
    print ( 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 ( 510 ) ; 
  else if ( ( b < 2672 ) && ( b != 7 ) ) 
  printnl ( 511 ) ; 
  else printnl ( 512 ) ; 
  printint ( n ) ; 
  print ( 744 ) ; 
  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 ( curcmd <= 3 ) 
      tnext () ; 
    } 
    if ( ldelim == 0 ) 
    {
      if ( curcmd > 81 ) 
      {
	if ( balance == 1 ) 
	goto lab30 ; 
	else if ( curcmd == 83 ) 
	decr ( balance ) ; 
      } 
      else if ( curcmd == 34 ) 
      incr ( balance ) ; 
    } 
    else {
	
      if ( curcmd == 64 ) 
      {
	if ( curmod == ldelim ) 
	{
	  decr ( balance ) ; 
	  if ( balance == 0 ) 
	  goto lab30 ; 
	} 
      } 
      else if ( curcmd == 33 ) 
      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 ; 
} 
void zmacrocall ( defref , arglist , macroname ) 
halfword defref ; 
halfword arglist ; 
halfword macroname ; 
{/* 40 */ halfword r  ; 
  halfword p, q  ; 
  integer n  ; 
  halfword ldelim, rdelim  ; 
  halfword tail  ; 
  r = mem [ defref ] .hhfield .v.RH ; 
  incr ( mem [ defref ] .hhfield .lhfield ) ; 
  if ( arglist == 0 ) 
  n = 0 ; 
  else {
      
    n = 1 ; 
    tail = arglist ; 
    while ( mem [ tail ] .hhfield .v.RH != 0 ) {
	
      incr ( n ) ; 
      tail = mem [ tail ] .hhfield .v.RH ; 
    } 
  } 
  if ( internal [ 8 ] > 0 ) 
  {
    begindiagnostic () ; 
    println () ; 
    printmacroname ( arglist , macroname ) ; 
    if ( n == 3 ) 
    print ( 706 ) ; 
    showmacro ( defref , 0 , 100000L ) ; 
    if ( arglist != 0 ) 
    {
      n = 0 ; 
      p = arglist ; 
      do {
	  q = mem [ p ] .hhfield .lhfield ; 
	printarg ( q , n , 0 ) ; 
	incr ( n ) ; 
	p = mem [ p ] .hhfield .v.RH ; 
      } while ( ! ( p == 0 ) ) ; 
    } 
    enddiagnostic ( false ) ; 
  } 
  curcmd = 82 ; 
  while ( mem [ r ] .hhfield .lhfield >= 2372 ) {
      
    if ( curcmd != 81 ) 
    {
      getxnext () ; 
      if ( curcmd != 33 ) 
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 750 ) ; 
	} 
	printmacroname ( arglist , macroname ) ; 
	{
	  helpptr = 3 ; 
	  helpline [ 2 ] = 751 ; 
	  helpline [ 1 ] = 752 ; 
	  helpline [ 0 ] = 753 ; 
	} 
	if ( mem [ r ] .hhfield .lhfield >= 2522 ) 
	{
	  curexp = 0 ; 
	  curtype = 20 ; 
	} 
	else {
	    
	  curexp = 0 ; 
	  curtype = 16 ; 
	} 
	backerror () ; 
	curcmd = 64 ; 
	goto lab40 ; 
      } 
      ldelim = cursym ; 
      rdelim = curmod ; 
    } 
    if ( mem [ r ] .hhfield .lhfield >= 2672 ) 
    scantextarg ( ldelim , rdelim ) ; 
    else {
	
      getxnext () ; 
      if ( mem [ r ] .hhfield .lhfield >= 2522 ) 
      scansuffix () ; 
      else scanexpression () ; 
    } 
    if ( curcmd != 81 ) 
    if ( ( curcmd != 64 ) || ( curmod != ldelim ) ) 
    if ( mem [ mem [ r ] .hhfield .v.RH ] .hhfield .lhfield >= 2372 ) 
    {
      missingerr ( 44 ) ; 
      {
	helpptr = 3 ; 
	helpline [ 2 ] = 754 ; 
	helpline [ 1 ] = 755 ; 
	helpline [ 0 ] = 749 ; 
      } 
      backerror () ; 
      curcmd = 81 ; 
    } 
    else {
	
      missingerr ( hash [ rdelim ] .v.RH ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 756 ; 
	helpline [ 0 ] = 749 ; 
      } 
      backerror () ; 
    } 
    lab40: {
	
      p = getavail () ; 
      if ( curtype == 20 ) 
      mem [ p ] .hhfield .lhfield = curexp ; 
      else mem [ p ] .hhfield .lhfield = stashcurexp () ; 
      if ( internal [ 8 ] > 0 ) 
      {
	begindiagnostic () ; 
	printarg ( mem [ p ] .hhfield .lhfield , n , mem [ r ] .hhfield .lhfield ) ; 
	enddiagnostic ( false ) ; 
      } 
      if ( arglist == 0 ) 
      arglist = p ; 
      else mem [ tail ] .hhfield .v.RH = p ; 
      tail = p ; 
      incr ( n ) ; 
    } 
    r = mem [ r ] .hhfield .v.RH ; 
  } 
  if ( curcmd == 81 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 745 ) ; 
    } 
    printmacroname ( arglist , macroname ) ; 
    printchar ( 59 ) ; 
    printnl ( 746 ) ; 
    print ( hash [ rdelim ] .v.RH ) ; 
    print ( 300 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 747 ; 
      helpline [ 1 ] = 748 ; 
      helpline [ 0 ] = 749 ; 
    } 
    error () ; 
  } 
  if ( mem [ r ] .hhfield .lhfield != 0 ) 
  {
    if ( mem [ r ] .hhfield .lhfield < 7 ) 
    {
      getxnext () ; 
      if ( mem [ r ] .hhfield .lhfield != 6 ) 
      if ( ( curcmd == 53 ) || ( curcmd == 76 ) ) 
      getxnext () ; 
    } 
    switch ( mem [ r ] .hhfield .lhfield ) 
    {case 1 : 
      scanprimary () ; 
      break ; 
    case 2 : 
      scansecondary () ; 
      break ; 
    case 3 : 
      scantertiary () ; 
      break ; 
    case 4 : 
      scanexpression () ; 
      break ; 
    case 5 : 
      {
	scanexpression () ; 
	p = getavail () ; 
	mem [ p ] .hhfield .lhfield = stashcurexp () ; 
	if ( internal [ 8 ] > 0 ) 
	{
	  begindiagnostic () ; 
	  printarg ( mem [ p ] .hhfield .lhfield , n , 0 ) ; 
	  enddiagnostic ( false ) ; 
	} 
	if ( arglist == 0 ) 
	arglist = p ; 
	else mem [ tail ] .hhfield .v.RH = p ; 
	tail = p ; 
	incr ( n ) ; 
	if ( curcmd != 70 ) 
	{
	  missingerr ( 489 ) ; 
	  print ( 757 ) ; 
	  printmacroname ( arglist , macroname ) ; 
	  {
	    helpptr = 1 ; 
	    helpline [ 0 ] = 758 ; 
	  } 
	  backerror () ; 
	} 
	getxnext () ; 
	scanprimary () ; 
      } 
      break ; 
    case 6 : 
      {
	if ( curcmd != 33 ) 
	ldelim = 0 ; 
	else {
	    
	  ldelim = cursym ; 
	  rdelim = curmod ; 
	  getxnext () ; 
	} 
	scansuffix () ; 
	if ( ldelim != 0 ) 
	{
	  if ( ( curcmd != 64 ) || ( curmod != ldelim ) ) 
	  {
	    missingerr ( hash [ rdelim ] .v.RH ) ; 
	    {
	      helpptr = 2 ; 
	      helpline [ 1 ] = 756 ; 
	      helpline [ 0 ] = 749 ; 
	    } 
	    backerror () ; 
	  } 
	  getxnext () ; 
	} 
      } 
      break ; 
    case 7 : 
      scantextarg ( 0 , 0 ) ; 
      break ; 
    } 
    backinput () ; 
    {
      p = getavail () ; 
      if ( curtype == 20 ) 
      mem [ p ] .hhfield .lhfield = curexp ; 
      else mem [ p ] .hhfield .lhfield = stashcurexp () ; 
      if ( internal [ 8 ] > 0 ) 
      {
	begindiagnostic () ; 
	printarg ( mem [ p ] .hhfield .lhfield , n , mem [ r ] .hhfield .lhfield ) ; 
	enddiagnostic ( false ) ; 
      } 
      if ( arglist == 0 ) 
      arglist = p ; 
      else mem [ tail ] .hhfield .v.RH = p ; 
      tail = p ; 
      incr ( n ) ; 
    } 
  } 
  r = mem [ r ] .hhfield .v.RH ; 
  while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) ) 
  endtokenlist () ; 
  if ( paramptr + n > maxparamstack ) 
  {
    maxparamstack = paramptr + n ; 
    if ( maxparamstack > 150 ) 
    overflow ( 728 , 150 ) ; 
  } 
  begintokenlist ( defref , 21 ) ; 
  curinput .namefield = macroname ; 
  curinput .locfield = r ; 
  if ( n > 0 ) 
  {
    p = arglist ; 
    do {
	paramstack [ paramptr ] = mem [ p ] .hhfield .lhfield ; 
      incr ( paramptr ) ; 
      p = mem [ p ] .hhfield .v.RH ; 
    } while ( ! ( p == 0 ) ) ; 
    flushlist ( arglist ) ; 
  } 
} 
void expand ( ) 
{halfword p  ; 
  integer k  ; 
  poolpointer j  ; 
  if ( internal [ 6 ] > 65536L ) 
  if ( curcmd != 13 ) 
  showcmdmod ( curcmd , curmod ) ; 
  switch ( curcmd ) 
  {case 4 : 
    conditional () ; 
    break ; 
  case 5 : 
    if ( curmod > iflimit ) 
    if ( iflimit == 1 ) 
    {
      missingerr ( 58 ) ; 
      backinput () ; 
      cursym = 2362 ; 
      inserror () ; 
    } 
    else {
	
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 765 ) ; 
      } 
      printcmdmod ( 5 , curmod ) ; 
      {
	helpptr = 1 ; 
	helpline [ 0 ] = 766 ; 
      } 
      error () ; 
    } 
    else {
	
      while ( curmod != 2 ) passtext () ; 
      {
	p = condptr ; 
	ifline = mem [ p + 1 ] .cint ; 
	curif = mem [ p ] .hhfield .b1 ; 
	iflimit = mem [ p ] .hhfield .b0 ; 
	condptr = mem [ p ] .hhfield .v.RH ; 
	freenode ( p , 2 ) ; 
      } 
    } 
    break ; 
  case 6 : 
    if ( curmod > 0 ) 
    forceeof = true ; 
    else startinput () ; 
    break ; 
  case 7 : 
    if ( curmod == 0 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 729 ) ; 
      } 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 730 ; 
	helpline [ 0 ] = 731 ; 
      } 
      error () ; 
    } 
    else beginiteration () ; 
    break ; 
  case 8 : 
    {
      while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) ) 
      endtokenlist () ; 
      if ( loopptr == 0 ) 
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 733 ) ; 
	} 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 734 ; 
	  helpline [ 0 ] = 735 ; 
	} 
	error () ; 
      } 
      else resumeiteration () ; 
    } 
    break ; 
  case 9 : 
    {
      getboolean () ; 
      if ( internal [ 6 ] > 65536L ) 
      showcmdmod ( 35 , curexp ) ; 
      if ( curexp == 30 ) 
      if ( loopptr == 0 ) 
      {
	{
	  if ( interaction == 3 ) 
	  ; 
	  printnl ( 263 ) ; 
	  print ( 736 ) ; 
	} 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 737 ; 
	} 
	if ( curcmd == 82 ) 
	error () ; 
	else backerror () ; 
      } 
      else {
	  
	p = 0 ; 
	do {
	    if ( ( curinput .indexfield <= 15 ) ) 
	  endfilereading () ; 
	  else {
	      
	    if ( curinput .indexfield <= 17 ) 
	    p = curinput .startfield ; 
	    endtokenlist () ; 
	  } 
	} while ( ! ( p != 0 ) ) ; 
	if ( p != mem [ loopptr ] .hhfield .lhfield ) 
	fatalerror ( 740 ) ; 
	stopiteration () ; 
      } 
      else if ( curcmd != 82 ) 
      {
	missingerr ( 59 ) ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 738 ; 
	  helpline [ 0 ] = 739 ; 
	} 
	backerror () ; 
      } 
    } 
    break ; 
  case 10 : 
    ; 
    break ; 
  case 12 : 
    {
      {
	getnext () ; 
	if ( curcmd <= 3 ) 
	tnext () ; 
      } 
      p = curtok () ; 
      {
	getnext () ; 
	if ( curcmd <= 3 ) 
	tnext () ; 
      } 
      if ( curcmd < 14 ) 
      expand () ; 
      else backinput () ; 
      begintokenlist ( p , 19 ) ; 
    } 
    break ; 
  case 11 : 
    {
      getxnext () ; 
      scanprimary () ; 
      if ( curtype != 4 ) 
      {
	disperr ( 0 , 741 ) ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 742 ; 
	  helpline [ 0 ] = 743 ; 
	} 
	putgetflusherror ( 0 ) ; 
      } 
      else {
	  
	backinput () ; 
	if ( ( strstart [ nextstr [ curexp ] ] - strstart [ curexp ] ) > 0 ) 
	{
	  beginfilereading () ; 
	  curinput .namefield = 2 ; 
	  k = first + ( strstart [ nextstr [ curexp ] ] - strstart [ curexp ] 
	  ) ; 
	  if ( k >= maxbufstack ) 
	  {
	    if ( k >= bufsize ) 
	    {
	      maxbufstack = bufsize ; 
	      overflow ( 256 , bufsize ) ; 
	    } 
	    maxbufstack = k + 1 ; 
	  } 
	  j = strstart [ curexp ] ; 
	  curinput .limitfield = k ; 
	  while ( first < curinput .limitfield ) {
	      
	    buffer [ first ] = strpool [ j ] ; 
	    incr ( j ) ; 
	    incr ( first ) ; 
	  } 
	  buffer [ curinput .limitfield ] = 37 ; 
	  first = curinput .limitfield + 1 ; 
	  curinput .locfield = curinput .startfield ; 
	  flushcurexp ( 0 ) ; 
	} 
      } 
    } 
    break ; 
  case 13 : 
    macrocall ( curmod , 0 , cursym ) ; 
    break ; 
  } 
} 
void getxnext ( ) 
{halfword saveexp  ; 
  {
    getnext () ; 
    if ( curcmd <= 3 ) 
    tnext () ; 
  } 
  if ( curcmd < 14 ) 
  {
    saveexp = stashcurexp () ; 
    do {
	if ( curcmd == 13 ) 
      macrocall ( curmod , 0 , cursym ) ; 
      else expand () ; 
      {
	getnext () ; 
	if ( curcmd <= 3 ) 
	tnext () ; 
      } 
    } while ( ! ( curcmd >= 14 ) ) ; 
    unstashcurexp ( saveexp ) ; 
  } 
} 
void zstackargument ( p ) 
halfword p ; 
{if ( paramptr == maxparamstack ) 
  {
    incr ( maxparamstack ) ; 
    if ( maxparamstack > 150 ) 
    overflow ( 728 , 150 ) ; 
  } 
  paramstack [ paramptr ] = p ; 
  incr ( paramptr ) ; 
} 
void passtext ( ) 
{/* 30 */ integer l  ; 
  scannerstatus = 1 ; 
  l = 0 ; 
  warninginfo = trueline () ; 
  while ( true ) {
      
    {
      getnext () ; 
      if ( curcmd <= 3 ) 
      tnext () ; 
    } 
    if ( curcmd <= 5 ) 
    if ( curcmd < 5 ) 
    incr ( l ) ; 
    else {
	
      if ( l == 0 ) 
      goto lab30 ; 
      if ( curmod == 2 ) 
      decr ( l ) ; 
    } 
    else if ( curcmd == 41 ) 
    {
      if ( strref [ curmod ] < 127 ) 
      if ( strref [ curmod ] > 1 ) 
      decr ( strref [ curmod ] ) ; 
      else flushstring ( curmod ) ; 
    } 
  } 
  lab30: scannerstatus = 0 ; 
} 
void zchangeiflimit ( l , p ) 
smallnumber l ; 
halfword p ; 
{/* 10 */ halfword q  ; 
  if ( p == condptr ) 
  iflimit = l ; 
  else {
      
    q = condptr ; 
    while ( true ) {
	
      if ( q == 0 ) 
      confusion ( 759 ) ; 
      if ( mem [ q ] .hhfield .v.RH == p ) 
      {
	mem [ q ] .hhfield .b0 = l ; 
	goto lab10 ; 
      } 
      q = mem [ q ] .hhfield .v.RH ; 
    } 
  } 
  lab10: ; 
} 
void checkcolon ( ) 
{if ( curcmd != 80 ) 
  {
    missingerr ( 58 ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 762 ; 
      helpline [ 0 ] = 739 ; 
    } 
    backerror () ; 
  } 
} 
void conditional ( ) 
{/* 10 30 21 40 */ halfword savecondptr  ; 
  char newiflimit  ; 
  halfword p  ; 
  {
    p = getnode ( 2 ) ; 
    mem [ p ] .hhfield .v.RH = condptr ; 
    mem [ p ] .hhfield .b0 = iflimit ; 
    mem [ p ] .hhfield .b1 = curif ; 
    mem [ p + 1 ] .cint = ifline ; 
    condptr = p ; 
    iflimit = 1 ; 
    ifline = trueline () ; 
    curif = 1 ; 
  } 
  savecondptr = condptr ; 
  lab21: getboolean () ; 
  newiflimit = 4 ; 
  if ( internal [ 6 ] > 65536L ) 
  {
    begindiagnostic () ; 
    if ( curexp == 30 ) 
    print ( 763 ) ; 
    else print ( 764 ) ; 
    enddiagnostic ( false ) ; 
  } 
  lab40: checkcolon () ; 
  if ( curexp == 30 ) 
  {
    changeiflimit ( newiflimit , savecondptr ) ; 
    goto lab10 ; 
  } 
  while ( true ) {
      
    passtext () ; 
    if ( condptr == savecondptr ) 
    goto lab30 ; 
    else if ( curmod == 2 ) 
    {
      p = condptr ; 
      ifline = mem [ p + 1 ] .cint ; 
      curif = mem [ p ] .hhfield .b1 ; 
      iflimit = mem [ p ] .hhfield .b0 ; 
      condptr = mem [ p ] .hhfield .v.RH ; 
      freenode ( p , 2 ) ; 
    } 
  } 
  lab30: curif = curmod ; 
  ifline = trueline () ; 
  if ( curmod == 2 ) 
  {
    p = condptr ; 
    ifline = mem [ p + 1 ] .cint ; 
    curif = mem [ p ] .hhfield .b1 ; 
    iflimit = mem [ p ] .hhfield .b0 ; 
    condptr = mem [ p ] .hhfield .v.RH ; 
    freenode ( p , 2 ) ; 
  } 
  else if ( curmod == 4 ) 
  goto lab21 ; 
  else {
      
    curexp = 30 ; 
    newiflimit = 2 ; 
    getxnext () ; 
    goto lab40 ; 
  } 
  lab10: ; 
} 
void zbadfor ( s ) 
strnumber s ; 
{disperr ( 0 , 767 ) ; 
  print ( s ) ; 
  print ( 307 ) ; 
  {
    helpptr = 4 ; 
    helpline [ 3 ] = 768 ; 
    helpline [ 2 ] = 769 ; 
    helpline [ 1 ] = 770 ; 
    helpline [ 0 ] = 309 ; 
  } 
  putgetflusherror ( 0 ) ; 
} 
void beginiteration ( ) 
{/* 22 30 */ halfword m  ; 
  halfword n  ; 
  halfword s  ; 
  halfword p  ; 
  halfword q  ; 
  halfword pp  ; 
  m = curmod ; 
  n = cursym ; 
  s = getnode ( 2 ) ; 
  if ( m == 1 ) 
  {
    mem [ s + 1 ] .hhfield .lhfield = 1 ; 
    p = 0 ; 
    getxnext () ; 
  } 
  else {
      
    getsymbol () ; 
    p = getnode ( 2 ) ; 
    mem [ p ] .hhfield .lhfield = cursym ; 
    mem [ p + 1 ] .cint = m ; 
    getxnext () ; 
    if ( curcmd == 74 ) 
    {
      getxnext () ; 
      scanexpression () ; 
      if ( curtype != 10 ) 
      {
	disperr ( 0 , 783 ) ; 
	{
	  helpptr = 1 ; 
	  helpline [ 0 ] = 784 ; 
	} 
	putgetflusherror ( getnode ( 8 ) ) ; 
	initedges ( curexp ) ; 
	curtype = 10 ; 
      } 
      mem [ s + 1 ] .hhfield .lhfield = curexp ; 
      curtype = 1 ; 
      q = mem [ curexp + 7 ] .hhfield .v.RH ; 
      if ( q != 0 ) 
      if ( ( mem [ q ] .hhfield .b0 >= 4 ) ) 
      if ( skip1component ( q ) == 0 ) 
      q = mem [ q ] .hhfield .v.RH ; 
      mem [ s + 1 ] .hhfield .v.RH = q ; 
    } 
    else {
	
      if ( ( curcmd != 53 ) && ( curcmd != 76 ) ) 
      {
	missingerr ( 61 ) ; 
	{
	  helpptr = 3 ; 
	  helpline [ 2 ] = 771 ; 
	  helpline [ 1 ] = 714 ; 
	  helpline [ 0 ] = 772 ; 
	} 
	backerror () ; 
      } 
      mem [ s + 1 ] .hhfield .lhfield = 0 ; 
      q = s + 1 ; 
      mem [ q ] .hhfield .v.RH = 0 ; 
      do {
	  getxnext () ; 
	if ( m != 2372 ) 
	scansuffix () ; 
	else {
	    
	  if ( curcmd >= 80 ) 
	  if ( curcmd <= 81 ) 
	  goto lab22 ; 
	  scanexpression () ; 
	  if ( curcmd == 72 ) 
	  if ( q == s + 1 ) 
	  {
	    if ( curtype != 16 ) 
	    badfor ( 778 ) ; 
	    pp = getnode ( 4 ) ; 
	    mem [ pp + 1 ] .cint = curexp ; 
	    getxnext () ; 
	    scanexpression () ; 
	    if ( curtype != 16 ) 
	    badfor ( 779 ) ; 
	    mem [ pp + 2 ] .cint = curexp ; 
	    if ( curcmd != 73 ) 
	    {
	      missingerr ( 500 ) ; 
	      {
		helpptr = 2 ; 
		helpline [ 1 ] = 780 ; 
		helpline [ 0 ] = 781 ; 
	      } 
	      backerror () ; 
	    } 
	    getxnext () ; 
	    scanexpression () ; 
	    if ( curtype != 16 ) 
	    badfor ( 782 ) ; 
	    mem [ pp + 3 ] .cint = curexp ; 
	    mem [ s + 1 ] .hhfield .v.RH = pp ; 
	    mem [ s + 1 ] .hhfield .lhfield = 2 ; 
	    goto lab30 ; 
	  } 
	  curexp = stashcurexp () ; 
	} 
	mem [ q ] .hhfield .v.RH = getavail () ; 
	q = mem [ q ] .hhfield .v.RH ; 
	mem [ q ] .hhfield .lhfield = curexp ; 
	curtype = 1 ; 
	lab22: ; 
      } while ( ! ( curcmd != 81 ) ) ; 
      lab30: ; 
    } 
  } 
  if ( curcmd != 80 ) 
  {
    missingerr ( 58 ) ; 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 773 ; 
      helpline [ 1 ] = 774 ; 
      helpline [ 0 ] = 775 ; 
    } 
    backerror () ; 
  } 
  q = getavail () ; 
  mem [ q ] .hhfield .lhfield = 2358 ; 
  scannerstatus = 6 ; 
  warninginfo = n ; 
  mem [ s ] .hhfield .lhfield = scantoks ( 7 , p , q , 0 ) ; 
  scannerstatus = 0 ; 
  mem [ s ] .hhfield .v.RH = loopptr ; 
  loopptr = s ; 
  resumeiteration () ; 
}