#include "externs.h"

#if defined(INITEX) || defined(TRIPTEX)
void F122_showeqtb (n)
/**************/
register int /* was T32_halfword */ n;
{
  if (n < 1)
    F16_printchar ((char)63);
  else
    if (n < 3526)
    {
      F24_sprintcs (n);
      F16_printchar ((char)61);
      F121_printcmdchr (eqtb[n]._TAG._TAG3.hh._TAG._TAG2.b0, eqtb[n]._TAG._TAG3.hh.rh);
      if (eqtb[n]._TAG._TAG3.hh._TAG._TAG2.b0 >= 110)
      {
	F16_printchar ((char)58);
	F73_showtokenlist (mem[eqtb[n]._TAG._TAG3.hh.rh - C2_memmin]._TAG._TAG3.hh.rh, (int)(-32768), 32L);
      }
    }
    else
      if (n < 4056)
	if (n < 3544)
	{
	  F104_printskipparam (n - 3526);
	  F16_printchar ((char)61);
	  if (n < 3541)
	    F98_printspec ((long)eqtb[n]._TAG._TAG3.hh.rh, 263);
	  else
	    F98_printspec ((long)eqtb[n]._TAG._TAG3.hh.rh, 206);
	}
	else
	  if (n < 3800)
	  {
	    F20_printesc (261);
	    F22_printint ((long)n - 3544);
	    F16_printchar ((char)61);
	    F98_printspec ((long)eqtb[n]._TAG._TAG3.hh.rh, 263);
	  }
	  else
	  {
	    F20_printesc (262);
	    F22_printint ((long)n - 3800);
	    F16_printchar ((char)61);
	    F98_printspec ((long)eqtb[n]._TAG._TAG3.hh.rh, 206);
	  }
      else
	if (n < 5267)
	  if (n == 4056)
	  {
	    F20_printesc (274);
	    F16_printchar ((char)61);
	    if (eqtb[4056]._TAG._TAG3.hh.rh == ((int)(-32768)))
	      F16_printchar ((char)48);
	    else
	      F22_printint ((long)mem[eqtb[4056]._TAG._TAG3.hh.rh - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh);
	  }
	  else
	    if (n < 4066)
	    {
	      F121_printcmdchr ((char)71, n);
	      F16_printchar ((char)61);
	      if (eqtb[n]._TAG._TAG3.hh.rh != ((int)(-32768)))
	      {
		F73_showtokenlist (mem[eqtb[n]._TAG._TAG3.hh.rh - C2_memmin]._TAG._TAG3.hh.rh, (int)(-32768), 32L);
	      }
	    }
	    else
	      if (n < 4322)
	      {
		F20_printesc (273);
		F22_printint ((long)n - 4066);
		F16_printchar ((char)61);
		if (eqtb[n]._TAG._TAG3.hh.rh != ((int)(-32768)))
		{
		  F73_showtokenlist (mem[eqtb[n]._TAG._TAG3.hh.rh - C2_memmin]._TAG._TAG3.hh.rh, (int)(-32768), 32L);
		}
	      }
	      else
		if (n < 4578)
		{
		  F20_printesc (275);
		  F22_printint ((long)n - 4322);
		  F16_printchar ((char)61);
		  if (eqtb[n]._TAG._TAG3.hh.rh == ((int)(-32768)))
		    F17_print (276);
		  else
		  {
		    depththreshold = 0;
		    breadthmax = 1;
		    F105_shownodelist (eqtb[n]._TAG._TAG3.hh.rh);
		  }
		}
		else
		  if (n < 4627)
		  {
		    if (n == 4578)
		      F17_print (277);
		    else
		      if (n < 4595)
		      {
			F20_printesc (278);
			F22_printint ((long)n - 4579);
		      }
		      else
			if (n < 4611)
			{
			  F20_printesc (279);
			  F22_printint ((long)n - 4595);
			}
			else
			{
			  F20_printesc (280);
			  F22_printint ((long)n - 4611);
			}
		    F16_printchar ((char)61);
		    F20_printesc (hash[3268 + eqtb[n]._TAG._TAG3.hh.rh - 258].rh);
		  }
		  else
		    if (n < 5139)
		    {
		      if (n < 4755)
		      {
			F20_printesc (281);
			F22_printint ((long)n - 4627);
		      }
		      else
			if (n < 4883)
			{
			  F20_printesc (282);
			  F22_printint ((long)n - 4755);
			}
			else
			  if (n < 5011)
			  {
			    F20_printesc (283);
			    F22_printint ((long)n - 4883);
			  }
			  else
			  {
			    F20_printesc (284);
			    F22_printint ((long)n - 5011);
			  }
		      F16_printchar ((char)61);
		      F22_printint ((long)eqtb[n]._TAG._TAG3.hh.rh);
		    }
		    else
		    {
		      F20_printesc (285);
		      F22_printint ((long)n - 5139);
		      F16_printchar ((char)61);
		      F22_printint ((long)eqtb[n]._TAG._TAG3.hh.rh + 32768);
		    }
	else
	  if (n < 5701)
	  {
	    if (n < 5317)
	      F116_printparam (n - 5267);
	    else
	      if (n < 5573)
	      {
		F20_printesc (337);
		F22_printint ((long)n - 5317);
	      }
	      else
	      {
		F20_printesc (338);
		F22_printint ((long)n - 5573);
	      }
	    F16_printchar ((char)61);
	    F22_printint (eqtb[n]._TAG._TAG1._int);
	  }
	  else
	    if (n <= 5976)
	    {
	      if (n < 5721)
		F120_printlengthparam (n - 5701);
	      else
	      {
		F20_printesc (360);
		F22_printint ((long)n - 5721);
	      }
	      F16_printchar ((char)61);
	      F67_printscaled (eqtb[n]._TAG._TAG1._int);
	      F17_print (263);
	    }
	    else
	      F16_printchar ((char)63);
}
# endif

int /* was T32_halfword */ F123_idlookup (j, l)
/*****************************/
register int   j;
register int   l;
{
  register int   h;
  register int /* was T32_halfword */ k;
  register int /* was T32_halfword */ p;
  register long help;
  register long help1;
  register int shelp;

  h = buffer[j];
  help=j+l;
  for (k = j + 1; k < help ; k++)
  {
    h += h + buffer[k];
    while (h >= 2551)
      h -= 2551;
  }
  p = h + 258;
  while (TRUE)
  {
    shelp = hash[p - 258].rh;
    if (shelp > 0)
      if ((strstart[shelp + 1] - strstart[shelp]) == l)
	if (!strncmp(&strpool[strstart[shelp]],&buffer[j],l))
	  /* was F55_streqbuf (shelp, j)) */
	  return(p);
    if (hash[p - 258]._TAG._TAG1.lh == 0)
    {
      if (nonewcontrolsequence)
	p = 3525;
      else
      {
	if (shelp > 0)
	{
	  do
	  {
	    if (hashused == 258)
	      F41_overflow (363, 3000L);
	    hashused--;
	  }
	  while (hash[hashused - 258].rh != 0);
	  hash[p - 258]._TAG._TAG1.lh = hashused;
	  p = hashused;
	}
	if ((poolptr + l) > C15_poolsize)
	  F41_overflow (129, (long)C15_poolsize - initpoolptr);
	help=j+l;
	for (k = j; k < help; k++)
	  strpool[poolptr++] = buffer[k];
	hash[p - 258].rh = F54_makestring ();
# if defined(INITEX) || defined(TRIPTEX)
	cscount++;
# endif
      }
      return(p);
    }
    p = hash[p - 258]._TAG._TAG1.lh;
  }
}

# if defined(INITEX) || defined(TRIPTEX)
void F124_primitive (s, c, o)
/*******************/
T26_strnumber s;
T31_quarterword c;
int /* was T32_halfword */ o;
{
#ifdef VAX
  register int j,k;
#else
  register T29_smallnumber j;
  register T25_poolpointer k;
#endif
  T29_smallnumber l;

  if (s < 128)
    curval = s + 129;
  else
  {
    k = strstart[s];
    l = strstart[s + 1] - k;
    for (j = 0; j < l; j++)
      buffer[j] = strpool[k+j];
    curval = F123_idlookup (0, l);
    poolptr = strstart[--strptr];
    hash[curval - 258].rh = s;
  }
  eqtb[curval]._TAG._TAG3.hh._TAG._TAG2.b1 = -127;
  eqtb[curval]._TAG._TAG3.hh._TAG._TAG2.b0 = c;
  eqtb[curval]._TAG._TAG3.hh.rh = o;
}
# endif

void F125_newsavelevel (c)
/******************/
T41_groupcode c;
{
  if (saveptr > maxsavestack)
  {
    maxsavestack = saveptr;
    if (maxsavestack > (C16_savesize - 6))
      F41_overflow (400, (long)C16_savesize);
  }
  savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 = 3;
  savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b1 = curgroup;
  savestack[saveptr]._TAG._TAG3.hh.rh = curboundary;
  if (curlevel == 127)
    F41_overflow (401, 255L);
  curboundary = saveptr;
  curlevel++;
  saveptr++;
  curgroup = c;
}

void F126_eqdestroy (w)
/***************/
register T37_memoryword w;
{
  register int /* was T32_halfword */ q;

  switch (w._TAG._TAG3.hh._TAG._TAG2.b0)
  {
    case 110: 
    case 111: 
    case 112: 
    case 113: 
      F107_deletetokenref (w._TAG._TAG3.hh.rh);
      break;
    case 116: 
      F108_deleteglueref (w._TAG._TAG3.hh.rh);
      break;
    case 117: 
      q = w._TAG._TAG3.hh.rh;
      if (q != ((int)(-32768)))
#ifdef NOSHIFT
	F78_freenode (q, (mem[q - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh * 2) + 1);
#else
	F78_freenode (q, (mem[q - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh << 1) + 1);
#endif
      break;
    case 118: 
      F109_flushnodelist (w._TAG._TAG3.hh.rh);
      break;
    default: 
      break;
  }
}

void F127_eqsave (p, l)
/**************/
int /* was T32_halfword */ p;
T31_quarterword l;
{
  if (saveptr > maxsavestack)
  {
    maxsavestack = saveptr;
    if (maxsavestack > (C16_savesize - 6))
      F41_overflow (400, (long)C16_savesize);
  }
  if (l == (-128))
    savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 = 1;
  else
  {
    savestack[saveptr++]=eqtb[p];
    savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 = 0;
  }
  savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b1 = l;
  savestack[saveptr++]._TAG._TAG3.hh.rh = p;
}

void F128_eqdefine (p, t, e)
/******************/
register int /* was T32_halfword */ p;
T31_quarterword t;
int /* was T32_halfword */ e;
{
  if (eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b1 == curlevel)
    F126_eqdestroy (eqtb[p]);
  else
    if (curlevel > -127)
      F127_eqsave (p, eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b1);
  eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b1 = curlevel;
  eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b0 = t;
  eqtb[p]._TAG._TAG3.hh.rh = e;
}

void F129_eqworddefine (p, w)
/********************/
register int /* was T32_halfword */ p;
long int   w;
{
  if (xeqlevel[p - 5267] != curlevel)
  {
    F127_eqsave (p, xeqlevel[p - 5267]);
    xeqlevel[p - 5267] = curlevel;
  }
  eqtb[p]._TAG._TAG1._int = w;
}

void F130_geqdefine (p, t, e)
/*******************/
register int /* was T32_halfword */ p;
T31_quarterword t;
int /* was T32_halfword */ e;
{
  F126_eqdestroy (eqtb[p]);
  eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b1 = -127;
  eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b0 = t;
  eqtb[p]._TAG._TAG3.hh.rh = e;
}

void F131_geqworddefine (p, w)
/*********************/
int /* was T32_halfword */ p;
long int   w;
{
  eqtb[p]._TAG._TAG1._int = w;
  xeqlevel[p - 5267] = -127;
}

void F132_saveforafter (t)
/******************/
int /* was T32_halfword */ t;
{
  if (saveptr > maxsavestack)
  {
    maxsavestack = saveptr;
    if (maxsavestack > (C16_savesize - 6))
      F41_overflow (400, (long)C16_savesize);
  }
  savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 = 2;
  savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b1 = -128;
  savestack[saveptr++]._TAG._TAG3.hh.rh = t;
}

# if defined(INITEX) || defined(TRIPTEX)
void F133_restoretrace (p, s)
/********************/
int /* was T32_halfword */ p;
T26_strnumber s;
{
  F118_begindiagnostic ();
  F16_printchar ((char)123);
  F17_print (s);
  F16_printchar ((char)32);
  F122_showeqtb (p);
  F16_printchar ((char)125);
  F119_enddiagnostic (FALSE);
}
# endif

void F135_unsave ()
/***********/
{
#ifdef VAX
register int l;
#else
  T31_quarterword l;
#endif
  register int /* was T32_halfword */ p;

  if (curlevel > -127)
  {
    curlevel--;
    while (TRUE)
    {
      if (savestack[--saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 == 3)
	goto _30;
      p = savestack[saveptr]._TAG._TAG3.hh.rh;
      if (savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 == 2)
      {
	register int /* was T32_halfword */ t;
	t = curtok;
	curtok = p;
	F134_backinput ();
	curtok = t;
      }
      else
      {
	if (savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b0 == 0)
	  l = savestack[saveptr--]._TAG._TAG3.hh._TAG._TAG2.b1;
	else
	  savestack[saveptr]=eqtb[3525];
	if (p < 5267)
	  if (eqtb[p]._TAG._TAG3.hh._TAG._TAG2.b1 == -127)
	  {
	    F126_eqdestroy (savestack[saveptr]);
# if defined(INITEX) || defined(TRIPTEX)
	    if (eqtb[5304]._TAG._TAG1._int > 0)
	      F133_restoretrace (p, 403);
# endif
	  }
	  else
	  {
	    F126_eqdestroy (eqtb[p]);
	    eqtb[p]=savestack[saveptr];
# if defined(INITEX) || defined(TRIPTEX)
	    if (eqtb[5304]._TAG._TAG1._int > 0)
	      F133_restoretrace (p, 404);
# endif
	  }
	else
	  if (xeqlevel[p - 5267] != (-127))
	  {
	    eqtb[p]=savestack[saveptr];
	    xeqlevel[p - 5267] = l;
# if defined(INITEX) || defined(TRIPTEX)
	    if (eqtb[5304]._TAG._TAG1._int > 0)
	      F133_restoretrace (p, 404);
# endif
	  }
	  else
	  {
# if defined(INITEX) || defined(TRIPTEX)
	    if (eqtb[5304]._TAG._TAG1._int > 0)
	      F133_restoretrace (p, 403)
# endif
	    ;
	  }
      }
    }
_30: 
    curgroup = savestack[saveptr]._TAG._TAG3.hh._TAG._TAG2.b1;
    curboundary = savestack[saveptr]._TAG._TAG3.hh.rh;
  }
  else
    F42_confusion (402);
}

void F136_preparemag ()
/***************/
{
  if ((magset > 0L) && (eqtb[5284]._TAG._TAG1._int != magset))
  {
    F19_printnl (134);
    F17_print (406);
    F22_printint (eqtb[5284]._TAG._TAG1._int);
    F17_print (407);
    F19_printnl (408);
    helpptr = 2;
    helpline[1] = 409;
    helpline[0] = 410;
    F63_interror (magset);
    F131_geqworddefine (5284, magset);
  }
  if ((eqtb[5284]._TAG._TAG1._int <= 0L) || (eqtb[5284]._TAG._TAG1._int > 32768L))
  {
    F19_printnl (134);
    F17_print (411);
    helpptr = 1;
    helpline[0] = 412;
    F63_interror (eqtb[5284]._TAG._TAG1._int);
    F131_geqworddefine (5284, 1000L);
  }
  magset = eqtb[5284]._TAG._TAG1._int;
}

void F138_printmeaning ()
/*****************/
{
  F121_printcmdchr ((char)curcmd, curchr);
  if (curcmd >= 110)
  {
    F16_printchar ((char)58);
    F15_println ();
    if (curchr != ((int)(-32768)))
      F73_showtokenlist (mem[curchr - C2_memmin]._TAG._TAG3.hh.rh, (int)(-32768), 1000L);
  }
  else
    if (curcmd == 109)
    {
      F16_printchar ((char)58);
      F15_println ();
      if (curmark[curchr] != ((int)(-32768)))
	F73_showtokenlist (mem[curmark[curchr] - C2_memmin]._TAG._TAG3.hh.rh, (int)(-32768), 1000L);
    }
}

void F139_showcurcmdchr ()
/******************/
{
  F118_begindiagnostic ();
  F19_printnl (123);
  if (curlist.modefield != shownmode)
  {
    F111_printmode (curlist.modefield);
    F17_print (427);
    shownmode = curlist.modefield;
  }
  F121_printcmdchr ((char)curcmd, curchr);
  F16_printchar ((char)125);
  F119_enddiagnostic (FALSE);
}

void F31_showcontext ()
/***************/
{
  register long int   q;
  register long int   n;
  register long int   p;
  register long int   i;
  register long int   j;
  register long int   l;
  register long int   m;
  register long int   oldsetting;

  baseptr = inputptr;
  inputstack[baseptr]=curinput;
  while (TRUE)
  {
    curinput=inputstack[baseptr];
    if ((((baseptr == inputptr) || (curinput.statefield != 0)) || (curinput.indexfield != 3)) || (curinput.locfield != ((int)(-32768))))
    {
      tally = 0;
      oldsetting = selector;
      if (curinput.statefield != 0)
      {
	if (curinput.namefield <= 17)
	  if (curinput.namefield == 0)
	    if (baseptr == 0)
	      F19_printnl (433);
	    else
	      F19_printnl (434);
	  else
	  {
	    F19_printnl (435);
	    if (curinput.namefield == 17)
	      F16_printchar ((char)42);
	    else
	      F22_printint ((long)curinput.namefield - 1);
	    F16_printchar ((char)62);
	  }
	else
	{
	  F19_printnl (436);
	  F22_printint (line);
	}
	F16_printchar ((char)32);
	l = tally;
	tally = 0;
	selector = 20;
	trickcount = 1000000;
	if (buffer[curinput.limitfield] == eqtb[5315]._TAG._TAG1._int)
	  j = curinput.limitfield;
	else
	  j = curinput.limitfield + 1;
	if (j > 0)
	  for (i = curinput.startfield; i < j; i++)
	  {
	    if (i == curinput.locfield)
	    {
	      firstcount = tally;
	      trickcount = ((tally + 1) + C4_errorline) - C5_halferrorline;
	      if (trickcount < (long)C4_errorline)
		trickcount = C4_errorline;
	    }
	    F17_print ((int)buffer[i]);
	  }
      }
      else
      {
	switch (curinput.indexfield)
	{
	  case 0: 
	    F19_printnl (437);
	    break;
	  case 1: 
	  case 2: 
	    F19_printnl (438);
	    break;
	  case 3: 
	    if (curinput.locfield == ((int)(-32768)))
	      F19_printnl (439);
	    else
	      F19_printnl (440);
	    break;
	  case 4: 
	    F19_printnl (441);
	    break;
	  case 5: 
	    F15_println ();
	    F23_printcs (curinput.namefield);
	    break;
	  case 6: 
	    F19_printnl (442);
	    break;
	  case 7: 
	    F19_printnl (443);
	    break;
	  case 8: 
	    F19_printnl (444);
	    break;
	  case 9: 
	    F19_printnl (445);
	    break;
	  case 10: 
	    F19_printnl (446);
	    break;
	  case 11: 
	    F19_printnl (447);
	    break;
	  case 12: 
	    F19_printnl (448);
	    break;
	  case 13: 
	    F19_printnl (449);
	    break;
	  case 14: 
	    F19_printnl (450);
	    break;
	  case 15: 
	    F19_printnl (451);
	    break;
	  default: 
	    F19_printnl (63);
	    break;
	}
	l = tally;
	tally = 0;
	selector = 20;
	trickcount = 1000000;
	if (curinput.indexfield < 5)
	{
	  F73_showtokenlist (curinput.startfield, curinput.locfield, 100000);
	}
	else
	{
	  F73_showtokenlist (mem[curinput.startfield - C2_memmin]._TAG._TAG3.hh.rh, curinput.locfield, 100000);
	}
      }
      selector = oldsetting;
      if (trickcount == 1000000)
      {
	firstcount = tally;
	trickcount = ((tally + 1) + C4_errorline) - C5_halferrorline;
	if (trickcount < C4_errorline)
	  trickcount = C4_errorline;
      }
      if (tally < trickcount)
	m = tally - firstcount;
      else
	m = trickcount - firstcount;
      if ((l + firstcount) <= (long)C5_halferrorline)
      {
	p = 0;
	n = l + firstcount;
      }
      else
      {
	F17_print (147);
	p = ((l + firstcount) - C5_halferrorline) + 3;
	n = C5_halferrorline;
      }
      for (q = p; q < firstcount; q++)
	F16_printchar (trickbuf[q % C4_errorline]);
      F15_println ();
      for (q = 1; q <= n; q++)
	F16_printchar ((char)32);
      if ((m + n) <= C4_errorline)
	p = firstcount + m;
      else
	p = firstcount + ((C4_errorline - n) - 3);
      for (q = firstcount; q < p; q++)
	F16_printchar (trickbuf[q % C4_errorline]);
      if ((m + n) > C4_errorline)
	F17_print (147);
    }
    if (curinput.statefield != 0)
      if ((curinput.namefield > 17) || (baseptr == 0))
	goto _30;
    baseptr--;
  }
_30: 
  curinput=inputstack[inputptr];
}

void F140_begintokenlist (p, t)
/**********************/
register int /* was T32_halfword */ p;
#ifdef VAX
register int t;
#else
T31_quarterword t;
#endif
{
  if (inputptr > maxinstack)
  {
    maxinstack = inputptr;
    if (inputptr == C7_stacksize)
      F41_overflow (452, (long)C7_stacksize);
  }
  inputstack[inputptr++]=curinput;
  curinput.statefield = 0;
  curinput.startfield = p;
  curinput.indexfield = t;
  if (t >= 5)
  {
    mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh++;
    if (t == 5)
      curinput.limitfield = paramptr;
    else
    {
      curinput.locfield = mem[p - C2_memmin]._TAG._TAG3.hh.rh;
      if (eqtb[5297]._TAG._TAG1._int > 1L)
      {
	F118_begindiagnostic ();
	F19_printnl (207);
	switch (t)
	{
	  case 14: 
	    F20_printesc (220);
	    break;
	  case 15: 
	    F20_printesc (453);
	    break;
	  default: 
	    F121_printcmdchr ((char)71, t + 4051);
	    break;
	}
	F17_print (415);
	if (p != ((int)(-32768)))
	  F73_showtokenlist (mem[p - C2_memmin]._TAG._TAG3.hh.rh, (int)(-32768), 1000L);
	F119_enddiagnostic (FALSE);
      }
    }
  }
  else
    curinput.locfield = p;
}

void F141_endtokenlist ()
/*****************/
{
  if (curinput.indexfield >= 3)
  {
    if (curinput.indexfield <= 4)
      F76_flushlist (curinput.startfield);
    else
    {
      F107_deletetokenref (curinput.startfield);
      if (curinput.indexfield == 5)
	while (paramptr > curinput.limitfield)
	  F76_flushlist (paramstack[--paramptr]);
    }
  }
  else
    if (curinput.indexfield == 1)
      alignstate = 0;
  curinput=inputstack[--inputptr];
  if (interrupt)
    F64_pauseforinstructions ();
}

void F134_backinput ()
/**************/
{
  register int /* was T32_halfword */ p;

  while ((curinput.statefield == 0) && (curinput.locfield == ((int)(-32768))))
    F141_endtokenlist ();
  p = F75_getavail ();
  mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = curtok;
  if (curtok < 768)
    if (curtok < 512)
      alignstate--;
    else
      alignstate++;
  if (inputptr > maxinstack)
  {
    maxinstack = inputptr;
    if (inputptr == C7_stacksize)
      F41_overflow (452, (long)C7_stacksize);
  }
  inputstack[inputptr++]=curinput;
  curinput.statefield = 0;
  curinput.startfield = p;
  curinput.indexfield = 3;
  curinput.locfield = p;
}

void F142_backerror ()
/**************/
{
  oktointerrupt = FALSE;
  F134_backinput ();
  oktointerrupt = TRUE;
  F39_error ();
}

void F143_inserror ()
/*************/
{
  oktointerrupt = FALSE;
  F134_backinput ();
  curinput.indexfield = 4;
  oktointerrupt = TRUE;
  F39_error ();
}

void F32_beginfilereading ()
/********************/
{

  if (inopen == C8_maxinopen)
    F41_overflow (454, (long)C8_maxinopen);
  if (first == C3_bufsize)
    F41_overflow (128, (long)C3_bufsize);
  inopen++;
  if (inputptr > maxinstack)
  {
    maxinstack = inputptr;
    if (inputptr == C7_stacksize)
      F41_overflow (452, (long)C7_stacksize);
  }
  inputstack[inputptr++]=curinput;
  curinput.indexfield = inopen;
  linestack[curinput.indexfield] = line;
  curinput.startfield = first;
  curinput.statefield = 1;
  curinput.namefield = 0;
}

void F144_endfilereading ()
/*******************/
{
  first = curinput.startfield;
  line = linestack[curinput.indexfield];
  if (curinput.namefield > 17)
    CLOSE_2(inputfile[curinput.indexfield]);
  curinput=inputstack[--inputptr];
  inopen--;
}

void F35_clearforerrorprompt ()
/***********************/
{
  while ((((curinput.statefield != 0) && (curinput.namefield == 0)) && (inputptr > 0)) && (curinput.locfield > curinput.limitfield))
    F144_endfilereading ();
  F15_println ();
}

void F145_checkoutervalidity ()
/***********************/
{
  register int /* was T32_halfword */ p;
  register int /* was T32_halfword */ q;

  if (scannerstatus != 0)
  {
    deletionsallowed = FALSE;
    if (curcs != 0)
    {
      if (((curinput.statefield == 0) || (curinput.namefield < 1)) || (curinput.namefield > 17))
      {
	p = F75_getavail ();
	mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = 4096 + curcs;
	F140_begintokenlist (p, (char)3);
      }
      curcmd = 10;
      curchr = 32;
    }
    if (scannerstatus > 1)
    {
      F74_runaway ();
      if (curcs == 0)
      {
	F19_printnl (134);
	F17_print (462);
      }
      else
      {
	curcs = 0;
	F19_printnl (134);
	F17_print (463);
      }
      F17_print (464);
      p = F75_getavail ();
      switch (scannerstatus)
      {
	case 2: 
	  F17_print (429);
	  mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = 637;
	  break;
	case 3: 
	  F17_print (470);
	  mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = partoken;
	  longstate = 112;
	  break;
	case 4: 
	  F17_print (431);
	  mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = 637;
	  q = p;
	  p = F75_getavail ();
	  mem[p - C2_memmin]._TAG._TAG3.hh.rh = q;
	  mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = 7355;
	  alignstate = -1000000;
	  break;
	case 5: 
	  F17_print (432);
	  mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = 637;
	  break;
      }
      F140_begintokenlist (p, (char)4);
      F17_print (465);
      F24_sprintcs ((int)warningindex);
      helpptr = 4;
      helpline[3] = 466;
      helpline[2] = 467;
      helpline[1] = 468;
      helpline[0] = 469;
      F39_error ();
    }
    else
    {
      F19_printnl (134);
      F17_print (456);
      F121_printcmdchr ((char)104, curif);
      F17_print (457);
      F22_printint ((long)skipline);
      helpptr = 3;
      helpline[2] = 458;
      helpline[1] = 459;
      helpline[0] = 460;
      if (curcs != 0)
	curcs = 0;
      else
	helpline[2] = 461;
      curtok = 7358;
      F143_inserror ();
    }
    deletionsallowed = TRUE;
  }
}

void F147_getnext ()
/************/
{
#ifdef M_XENIX
  T37_memoryword huge *memptr;
#else
  register T37_memoryword *memptr;
#endif
  register int   k;
  register int   cat;
  register int /* was T32_halfword */ t;
  register T37_memoryword memhelp;

_20: 
  curcs = 0;
  if (curinput.statefield != 0)
  {
_25: 
    if (curinput.locfield <= curinput.limitfield)
    {
      curchr = buffer[curinput.locfield++];
  _21: 
      curcmd = eqtb[4627 + curchr]._TAG._TAG3.hh.rh;
      switch (curinput.statefield + curcmd)
      {
	case 10: 
	case 26: 
	case 27: 
	case 42: 
	case 43: 
	  goto _25;
	  break;
	case 1: 
	case 17: 
	case 33: 
	  if (curinput.locfield > curinput.limitfield)
	    curcs = 257;
	  else
	  {
	_26: 
	    k = curinput.locfield;
	    curchr = buffer[k++];
	    cat = eqtb[4627 + curchr]._TAG._TAG3.hh.rh;
	    if ((cat == 11)||(cat == 10))
	      curinput.statefield = 17;
	    else
	      curinput.statefield = 1;
	    if ((cat == 11) && (k <= curinput.limitfield))
	    {
	      do
		cat = eqtb[4627 + buffer[k++]]._TAG._TAG3.hh.rh;
	      while ((cat == 11) && (k <= curinput.limitfield));
	      curchr = buffer[k-1];
	      if (buffer[k] == curchr)
		if (cat == 7)
		  if (k < curinput.limitfield)
		  {
		    curchr = buffer[k + 1];
		    buffer[k-1]= (curchr < 64)?(curchr + 64):(curchr - 64);
		    curinput.limitfield -= 2;
		    first -= 2;
		    while (k <= curinput.limitfield)
		    {
		      buffer[k] = buffer[k + 2];
		      k++;
		    }
		    goto _26;
		  }
	      if (cat != 11)
		k--;
	      if (k > (curinput.locfield+1))
	      {
		curcs = F123_idlookup (curinput.locfield, k - curinput.locfield);
		curinput.locfield = k;
		goto _40;
	      }
	    }
	    else
	    {
	      if (buffer[k] == curchr)
		if (cat == 7)
		    if (k < curinput.limitfield)
		    {
		      curchr = buffer[k + 1];
		      buffer[k-1]=(curchr < 64)?(curchr + 64):(curchr - 64);
		      curinput.limitfield -= 2;
		      first -= 2;
		      while (k <= curinput.limitfield)
		      {
			buffer[k] = buffer[k + 2];
			k++;
		      }
		      goto _26;
		    }
	    }
	    curcs = 129 + buffer[curinput.locfield++];
	  }
      _40: 
	  curcmd = eqtb[curcs]._TAG._TAG3.hh._TAG._TAG2.b0;
	  curchr = eqtb[curcs]._TAG._TAG3.hh.rh;
	  if (curcmd >= 112)
	    F145_checkoutervalidity ();
	  break;
	case 14: 
	case 30: 
	case 46: 
	  curcs = curchr + 1;
	  curcmd = eqtb[curcs]._TAG._TAG3.hh._TAG._TAG2.b0;
	  curchr = eqtb[curcs]._TAG._TAG3.hh.rh;
	  curinput.statefield = 1;
	  if (curcmd >= 112)
	    F145_checkoutervalidity ();
	  break;
	case 8: 
	case 24: 
	case 40: 
	  if ((curchr == buffer[curinput.locfield]) && (curinput.locfield < curinput.limitfield))
	  {
	    curchr=buffer[curinput.locfield + 1];
	    if (curchr<64)
	      curchr+=64;
	    else
	      curchr-=64;
	    curinput.locfield+= 2;
	    goto _21;
	  }
	  curinput.statefield = 1;
	  break;
	case 16: 
	case 32: 
	case 48: 
	  F19_printnl (134);
	  F17_print (471);
	  helpptr = 2;
	  helpline[1] = 472;
	  helpline[0] = 473;
	  deletionsallowed = FALSE;
	  F39_error ();
	  deletionsallowed = TRUE;
	  goto _20;
	  break;
	case 11: 
	  curinput.statefield = 17;
	  curchr = 32;
	  break;
	case 6: 
	  curinput.locfield = curinput.limitfield + 1;
	  curcmd = 10;
	  curchr = 32;
	  break;
	case 22: 
	case 15: 
	case 31: 
	case 47: 
	  curinput.locfield = curinput.limitfield + 1;
	  goto _25;
	  break;
	case 38: 
	  curinput.locfield = curinput.limitfield + 1;
	  curcs = parloc;
	  curcmd = eqtb[curcs]._TAG._TAG3.hh._TAG._TAG2.b0;
	  curchr = eqtb[curcs]._TAG._TAG3.hh.rh;
	  if (curcmd >= 112)
	    F145_checkoutervalidity ();
	  break;
	case 2: 
	  alignstate++;
	  break;
	case 18: 
	case 34: 
	  curinput.statefield = 1;
	  alignstate++;
	  break;
	case 3: 
	  alignstate--;
	  break;
	case 19: 
	case 35: 
	  curinput.statefield = 1;
	  alignstate--;
	  break;
	case 20: 
	case 21: 
	case 23: 
	case 25: 
	case 28: 
	case 29: 
	case 36: 
	case 37: 
	case 39: 
	case 41: 
	case 44: 
	case 45: 
	  curinput.statefield = 1;
	  break;
	default: 
	  break;
      }
    }
    else
    {
      curinput.statefield = 33;
      if (curinput.namefield > 17)
      {
	line++;
	first = curinput.startfield;
	if (!forceeof)
	{
	  if (F52_inputln (inputfile[curinput.indexfield].fp))
	    F146_firmuptheline ();
	  else
	    forceeof = TRUE;
	}
	if (forceeof)
	{
	  F16_printchar ((char)41);
	  forceeof = FALSE;

	  fflush(stdout);
	  F144_endfilereading ();
	  F145_checkoutervalidity ();
	  goto _20;
	}
	if ((eqtb[5315]._TAG._TAG1._int < 0) || (eqtb[5315]._TAG._TAG1._int > 127))
	  curinput.limitfield--;
	else
	  buffer[curinput.limitfield] = eqtb[5315]._TAG._TAG1._int;
	first = curinput.limitfield + 1;
	curinput.locfield = curinput.startfield;
      }
      else
      {
	if (curinput.namefield != 0)
	{
	  curcmd = 0;
	  curchr = 0;
	  return;
	}
	if (inputptr > 0)
	{
	  F144_endfilereading ();
	  goto _20;
	}
	if (selector < 18)
	  F33_openlogfile ();
	if (interaction > 1)
	{
	  if (curinput.limitfield == curinput.startfield)
	    F19_printnl (474);
	  F15_println ();
	  first = curinput.startfield;
	  F17_print (42);
	  F30_terminput ();
	  curinput.limitfield = last;
	  if ((eqtb[5315]._TAG._TAG1._int < 0) || (eqtb[5315]._TAG._TAG1._int > 127))
	    curinput.limitfield--;
	  else
	    buffer[curinput.limitfield] = eqtb[5315]._TAG._TAG1._int;
	  first = curinput.limitfield + 1;
	  curinput.locfield = curinput.startfield;
	}
	else
	  F40_fatalerror (475);
      }
      if (interrupt != 0)
	F64_pauseforinstructions ();
      goto _25;
    }
  }
  else
    if (curinput.locfield != (int)(-32768))
    {
      memhelp=mem[curinput.locfield - C2_memmin];
      t = memhelp._TAG._TAG3.hh._TAG._TAG1.lh;
      curinput.locfield = memhelp._TAG._TAG3.hh.rh;
      if (t >= 4096)
      {
	curcs = t - 4096;
	curcmd = eqtb[curcs]._TAG._TAG3.hh._TAG._TAG2.b0;
	curchr = eqtb[curcs]._TAG._TAG3.hh.rh;
	if (curcmd >= 112)
	  if (curcmd == 115)
	  {
	    curcs = mem[curinput.locfield - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh - 4096;
	    curinput.locfield = (int)(-32768);
	    curcmd = eqtb[curcs]._TAG._TAG3.hh._TAG._TAG2.b0;
	    curchr = eqtb[curcs]._TAG._TAG3.hh.rh;
	    if (curcmd > 99)
	    {
	      curcmd = 0;
	      curchr = 257;
	    }
	  }
	  else
	    F145_checkoutervalidity ();
      }
      else
      {
	curcmd = t >> 8;
	curchr = t & 255;
	switch (curcmd)
	{
	  case 1: 
	    alignstate++;
	    break;
	  case 2: 
	    alignstate--;
	    break;
	  case 5: 
	    F140_begintokenlist (paramstack[(curinput.limitfield + curchr) - 1], (char)0);
	    goto _20;
	    break;
	  default: 
	    break;
	}
      }
    }
    else
    {
      F141_endtokenlist ();
      goto _20;
    }
  if (curcmd <= 5)
    if (curcmd >= 4)
      if (alignstate == 0)
      {
	if (scannerstatus == 4)
	  F40_fatalerror (762);
	memptr = &mem[curalign + 5 - C2_memmin];
	curcmd = memptr->_TAG._TAG3.hh._TAG._TAG1.lh;
	memptr->_TAG._TAG3.hh._TAG._TAG1.lh = curchr;
	if (curcmd == 63)
# ifdef TRIPTEX
	  F140_begintokenlist (2990, (char)2);
# else
	  F140_begintokenlist (29990, (char)2);
# endif
	else
	  F140_begintokenlist ((int)((memptr-3)->_TAG._TAG1._int), (char)2);
	alignstate = 1000000;
	goto _20;
      }
}

void F146_firmuptheline ()
/******************/
{
  register int   k;

  curinput.limitfield = last;
  if (eqtb[5295]._TAG._TAG1._int > 0L)
    if (interaction > 1)
    {
      F15_println ();
      if (curinput.startfield < curinput.limitfield)
	for (k = curinput.startfield; k < curinput.limitfield; k++)
	  F17_print ((int)buffer[k]);
      first = curinput.limitfield;
      F17_print (476);
      F30_terminput ();
      if (last > first)
      {
	register int help;
	help = curinput.startfield - first;
	for (k = first; k < last; k++)
	  buffer[k + help] = buffer[k];
	curinput.limitfield = help + last;
      }
    }
}

void F148_macrocall ()
/**************/
{
#ifdef M_XENIX
  T37_memoryword huge *memptr;
#else
  register T37_memoryword *memptr;
#endif
  register int /* was T32_halfword */ r;
  register int /* was T32_halfword */ q;
  register int /* was T32_halfword */ p;
  register int /* was T32_halfword */ m;
  register T21_asciicode matchchr;
  register T29_smallnumber n;
  register int /* was T32_halfword */ rbraceptr;
  register int /* was T32_halfword */ refcount;
  register int /* was T32_halfword */ s;
  register T29_smallnumber savescannerstatus;
  register int /* was T32_halfword */ savewarningindex;
  register int /* was T32_halfword */ t;
  register int /* was T32_halfword */ u;
  register int /* was T32_halfword */ unbalance;
  register int /* was T32_halfword */ v;
  register int shelp;
  register long help;
  register T37_memoryword memhelp,memhelp1,memhelp2;

  savescannerstatus = scannerstatus;
  savewarningindex = warningindex;
  warningindex = curcs;
  refcount = curchr;
  r = mem[refcount - C2_memmin]._TAG._TAG3.hh.rh;
  n = 0;
  if (eqtb[5297]._TAG._TAG1._int > 0L)
  {
    F118_begindiagnostic ();
    F15_println ();
    F23_printcs (warningindex);
    if (refcount != ((int)(-32768)))
      F73_showtokenlist (r /*mem[refcount - C2_memmin]._TAG._TAG3.hh.rh*/, (int)(-32768), 1000L);
    F119_enddiagnostic (FALSE);
  }
  if (mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh != 3584)
  {
    scannerstatus = 3;
    unbalance = 0;
    longstate = eqtb[curcs]._TAG._TAG3.hh._TAG._TAG2.b0;
    if (longstate >= 112)
      longstate -= 2;
    do
    {
      register int shelp;
      shelp = mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh;
      if ((shelp > 3455) || (shelp < 3328))
	s = (int)(-32768);
      else
      {
	matchchr = shelp - 3328;
	r = s = mem[r - C2_memmin]._TAG._TAG3.hh.rh;
# ifdef TRIPTEX
	p = 2997;
# else
	p = 29997;
# endif
	mem[p - C2_memmin]._TAG._TAG3.hh.rh = (int)(-32768);
	m = 0;
      }
  _22: 
      F29_gettoken (null);
      if (curtok == mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh)
      {
	r = mem[r - C2_memmin]._TAG._TAG3.hh.rh;
	shelp = mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh;
	if ((shelp >= 3328) && (shelp <= 3584))
	{
	  if (curtok < 512)
	    alignstate--;
	  goto _40;
	}
	else
	  goto _22;
      }
      if (s != r)
	if (s == (int)(-32768))
	{
	  F19_printnl (134);
	  F17_print (508);
	  F24_sprintcs ((int)warningindex);
	  F17_print (509);
	  helpptr = 4;
	  helpline[3] = 510;
	  helpline[2] = 511;
	  helpline[1] = 512;
	  helpline[0] = 513;
	  F39_error ();
	  goto _10;
	}
	else
	{
	  t = s;
	  do
	  {
	    q = F75_getavail ();
	    mem[p - C2_memmin]._TAG._TAG3.hh.rh = q;
	    memhelp2 = mem[t - C2_memmin];
	    mem[q - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = memhelp2._TAG._TAG3.hh._TAG._TAG1.lh;
	    p = q;
	    m++;
	    u = memhelp2._TAG._TAG3.hh.rh;
	    v = s;
	    while (TRUE)
	    {
	      memhelp = mem[v - C2_memmin];
	      if (u == r)
	      {
		if (curtok != memhelp._TAG._TAG3.hh._TAG._TAG1.lh)
		  goto _30;
		else
		{
		  r = memhelp._TAG._TAG3.hh.rh;
		  goto _22;
		}
	      }
	      memhelp1 = mem[u - C2_memmin];
	      if (memhelp1._TAG._TAG3.hh._TAG._TAG1.lh != memhelp._TAG._TAG3.hh._TAG._TAG1.lh)
		goto _30;
	      u = memhelp1._TAG._TAG3.hh.rh;
	      v = memhelp._TAG._TAG3.hh.rh;
	    }
	_30: 
	    t = memhelp2._TAG._TAG3.hh.rh;
	  }
	  while (t != r);
	  r = s;
	}
      if (curtok == partoken)
	if (longstate != 111)
	{
	  if (longstate == 110)
	  {
	    F74_runaway ();
	    F19_printnl (134);
	    F17_print (503);
	    F24_sprintcs ((int)warningindex);
	    F17_print (504);
	    helpptr = 3;
	    helpline[2] = 505;
	    helpline[1] = 506;
	    helpline[0] = 507;
	    F142_backerror ();
	  }
	  pstack[n] = m29997->_TAG._TAG3.hh.rh;
	  alignstate -= unbalance;
	  {
	    register int m;
	    for (m = 0; m <= n; m++)
	      F76_flushlist (pstack[m]);
	  }
	  goto _10;
	}
      if (curtok < 768)
	if (curtok < 512)
	{
	  unbalance = 1;
	  while (TRUE)
	  {
	    q = avail;
	    if (q == (int)(-32768))
	      q = F75_getavail ();
	    else
	    {
	      memptr = &mem[q - C2_memmin];
	      avail = memptr->_TAG._TAG3.hh.rh;
	      memptr->_TAG._TAG3.hh.rh = (int)(-32768);
# if defined(INITEX) || defined(TRIPTEX)
	      dynused++;
# endif
	    }
	    mem[p - C2_memmin]._TAG._TAG3.hh.rh = q;
	    mem[q - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = curtok;
	    p = q;
	    F29_gettoken (null);
	    if (curtok == partoken)
	      if (longstate != 111)
	      {
		if (longstate == 110)
		{
		  F74_runaway ();
		  F19_printnl (134);
		  F17_print (503);
		  F24_sprintcs ((int)warningindex);
		  F17_print (504);
		  helpptr = 3;
		  helpline[2] = 505;
		  helpline[1] = 506;
		  helpline[0] = 507;
		  F142_backerror ();
		}
		pstack[n] = m29997->_TAG._TAG3.hh.rh;
		alignstate -= unbalance;
		{
		  register int m;
		  for (m = 0; m <= n; m++)
		    F76_flushlist (pstack[m]);
		}
		goto _10;
	      }
	    if (curtok < 768)
	      if (curtok < 512)
		unbalance++;
	      else
	      {
		unbalance--;
		if (unbalance == 0)
		  goto _31;
	      }
	  }
      _31: 
	  rbraceptr = p;
	  {
	    q = F75_getavail ();
	    mem[p - C2_memmin]._TAG._TAG3.hh.rh = q;
	    mem[q - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = curtok;
	    p = q;
	  }
	}
	else
	{
	  F134_backinput ();
	  F19_printnl (134);
	  F17_print (495);
	  F24_sprintcs ((int)warningindex);
	  F17_print (496);
	  helpptr = 6;
	  helpline[5] = 497;
	  helpline[4] = 498;
	  helpline[3] = 499;
	  helpline[2] = 500;
	  helpline[1] = 501;
	  helpline[0] = 502;
	  alignstate++;
	  longstate = 110;
	  curtok = partoken;
	  F143_inserror ();
	}
      else
      {
	if (curtok == 2592)
	{
	  register int shelp;
	  shelp = mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh;
	  if ((shelp <= 3584) && (shelp >= 3328))
	    goto _22;
	}
	q = F75_getavail ();
	mem[p - C2_memmin]._TAG._TAG3.hh.rh = q;
	mem[q - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh = curtok;
	p = q;
      }
      m++;
      {
	register int shelp;
	shelp = mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh;
	if ((shelp > 3584) || (shelp < 3328))
	  goto _22;
      }
  _40: 
      if (s != (int)(-32768))
      {
#ifdef TRIPTEX
	if (((m == 1) && (mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh < 768)) && (p != 2997))
#else
	if ((m == 1) && (mem[p - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh < 768) && (p != 29997))
#endif
	{
	  mem[rbraceptr - C2_memmin]._TAG._TAG3.hh.rh = -32768;
	  mem[p - C2_memmin]._TAG._TAG3.hh.rh = avail;
	  avail = p;
# if defined(INITEX) || defined(TRIPTEX)
	  dynused--;
# endif
	  p = m29997->_TAG._TAG3.hh.rh;
	  memptr = &mem[p - C2_memmin];
	  pstack[n] = memptr->_TAG._TAG3.hh.rh;
	  memptr->_TAG._TAG3.hh.rh = avail;
	  avail = p;
# if defined(INITEX) || defined(TRIPTEX)
	  dynused--;
# endif
	}
	else
	  pstack[n] = m29997->_TAG._TAG3.hh.rh;
	n++;
	if (eqtb[5297]._TAG._TAG1._int > 0L)
	{
	  F118_begindiagnostic ();
	  F19_printnl (matchchr);
	  F22_printint ((long)n);
	  F17_print (514);
	  F73_showtokenlist (pstack[n - 1], (int)(-32768), 1000L);
	  F119_enddiagnostic (FALSE);
	}
      }
    }
    while (mem[r - C2_memmin]._TAG._TAG3.hh._TAG._TAG1.lh != 3584);
  }
  while ((curinput.statefield == 0) && (curinput.locfield == -32768))
    F141_endtokenlist ();
  F140_begintokenlist (refcount, (char)5);
  curinput.namefield = warningindex;
  curinput.locfield = mem[r - C2_memmin]._TAG._TAG3.hh.rh;
  if (n > 0)
  {
    if ((paramptr + n) > maxparamstack)
    {
      maxparamstack = paramptr + n;
      if (maxparamstack > C11_paramsize)
	F41_overflow (494, (long)C11_paramsize);
    }
    {
      register int m;
      for (m = 0; m < n; m++)
	paramstack[paramptr + m] = pstack[m];
    }
    paramptr += n;
  }
_10: 
  scannerstatus = savescannerstatus;
  warningindex = savewarningindex;
}
