#define EXTERN extern
#include "mpd.h"

boolean initterminal ( ) 
{/* 10 22 */ register boolean Result; integer i, j, k  ; 
  char arg[101]  ; 
  boolean firsttime  ; 
  termin = stdin ; 
  if ( argc > 1 ) 
  {
    last = first ; 
    {register integer for_end; i = 2 ; for_end = argc ; if ( i <= for_end) do 
      {
	argv ( i , arg ) ; 
	j = 1 ; 
	k = 1 ; 
	while ( ( k < 100 ) && ( arg [ k ] != 0 ) ) incr ( k ) ; 
	decr ( k ) ; 
	while ( ( k > 1 ) && ( arg [ k ] == ' ' ) ) decr ( k ) ; 
	if ( ( k == 2 ) && ( arg [ 1 ] == '-' ) && ( last == first ) ) 
	if ( arg [ 2 ] == 'I' ) 
	{
	;
#ifdef INIMP
	  memident = 257 ; 
	  goto lab22 ; 
#endif /* INIMP */
	} 
	else if ( arg [ 2 ] == 'T' ) 
	{
	  troffmode = true ; 
	  goto lab22 ; 
	} 
	while ( ( j <= k ) ) {
	    
	  buffer [ last ] = xord [ arg [ j ] ] ; 
	  incr ( j ) ; 
	  incr ( last ) ; 
	} 
	if ( k > 1 ) 
	{
	  buffer [ last ] = xord [ ' ' ] ; 
	  incr ( last ) ; 
	} 
	lab22: ; 
      } 
    while ( i++ < for_end ) ; } 
    if ( last > first ) 
    {
      curinput .locfield = first ; 
      Result = true ; 
      goto lab10 ; 
    } 
  } 
  firsttime = true ; 
  while ( true ) {
      
    ; 
    Fputs( termout ,  "**" ) ; 
    flush ( termout ) ; 
    if ( ! inputln ( termin , ! firsttime ) ) 
    {
      putc ('\n',  termout );
      fprintf( termout , "%s\n",  "! End of file on the terminal... why?" ) ; 
      Result = false ; 
      goto lab10 ; 
    } 
    firsttime = false ; 
    curinput .locfield = first ; 
    while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
    == 32 ) ) incr ( curinput .locfield ) ; 
    if ( curinput .locfield < last ) 
    {
      Result = true ; 
      goto lab10 ; 
    } 
    fprintf( termout , "%s\n",  "Please type the name of your input file." ) ; 
  } 
  lab10: ; 
  return(Result) ; 
} 
#ifdef INIMP
boolean getstringsstarted ( ) 
{/* 30 10 */ register boolean Result; unsigned char k, l  ; 
  char m, n  ; 
  strnumber g  ; 
  integer a  ; 
  boolean c  ; 
  poolptr = 0 ; 
  strptr = 0 ; 
  maxpoolptr = 0 ; 
  maxstrptr = 0 ; 
  strstart [ 0 ] = 0 ; 
  nextstr [ 0 ] = 1 ; 
  stroverflowed = false ; 
	;
#ifdef STAT
  poolinuse = 0 ; 
  strsinuse = 0 ; 
  maxplused = 0 ; 
  maxstrsused = 0 ; 
  pactcount = 0 ; 
  pactchars = 0 ; 
  pactstrs = 0 ; 
#endif /* STAT */
  strsusedup = 0 ; 
  {register integer for_end; k = 0 ; for_end = 255 ; if ( k <= for_end) do 
    {
      if ( ( ( k < 32 ) || ( k > 126 ) ) ) 
      {
	{
	  strpool [ poolptr ] = 94 ; 
	  incr ( poolptr ) ; 
	} 
	{
	  strpool [ poolptr ] = 94 ; 
	  incr ( poolptr ) ; 
	} 
	if ( k < 64 ) 
	{
	  strpool [ poolptr ] = k + 64 ; 
	  incr ( poolptr ) ; 
	} 
	else if ( k < 128 ) 
	{
	  strpool [ poolptr ] = k - 64 ; 
	  incr ( poolptr ) ; 
	} 
	else {
	    
	  l = k / 16 ; 
	  if ( l < 10 ) 
	  {
	    strpool [ poolptr ] = l + 48 ; 
	    incr ( poolptr ) ; 
	  } 
	  else {
	      
	    strpool [ poolptr ] = l + 87 ; 
	    incr ( poolptr ) ; 
	  } 
	  l = k % 16 ; 
	  if ( l < 10 ) 
	  {
	    strpool [ poolptr ] = l + 48 ; 
	    incr ( poolptr ) ; 
	  } 
	  else {
	      
	    strpool [ poolptr ] = l + 87 ; 
	    incr ( poolptr ) ; 
	  } 
	} 
      } 
      else {
	  
	strpool [ poolptr ] = k ; 
	incr ( poolptr ) ; 
      } 
      g = makestring () ; 
      strref [ g ] = 127 ; 
    } 
  while ( k++ < for_end ) ; } 
  (void) strncpy(nameoffile+1, poolname, sizeof poolname) ; 
  if ( aopenin ( poolfile , 11 ) ) 
  {
    c = false ; 
    do {
	{ 
	if ( eof ( poolfile ) ) 
	{
	  ; 
	  fprintf( termout , "%s\n",  "! mp.pool has no check sum." ) ; 
	  aclose ( poolfile ) ; 
	  Result = false ; 
	  goto lab10 ; 
	} 
	read (poolfile , m); read (poolfile, n ) ; 
	if ( m == '*' ) 
	{
	  a = 0 ; 
	  k = 1 ; 
	  while ( true ) {
	      
	    if ( ( xord [ n ] < 48 ) || ( xord [ n ] > 57 ) ) 
	    {
	      ; 
	      fprintf( termout , "%s\n",                "! mp.pool check sum doesn't have nine digits." ) ; 
	      aclose ( poolfile ) ; 
	      Result = false ; 
	      goto lab10 ; 
	    } 
	    a = 10 * a + xord [ n ] - 48 ; 
	    if ( k == 9 ) 
	    goto lab30 ; 
	    incr ( k ) ; 
	    read ( poolfile , n ) ; 
	  } 
	  lab30: if ( a != 473641430L ) 
	  {
	    ; 
	    fprintf( termout , "%s\n",  "! mp.pool doesn't match; tangle me again." ) 
	    ; 
	    aclose ( poolfile ) ; 
	    Result = false ; 
	    goto lab10 ; 
	  } 
	  c = true ; 
	} 
	else {
	    
	  if ( ( xord [ m ] < 48 ) || ( xord [ m ] > 57 ) || ( xord [ n ] < 48 
	  ) || ( xord [ n ] > 57 ) ) 
	  {
	    ; 
	    fprintf( termout , "%s\n",              "! mp.pool line doesn't begin with two digits." ) ; 
	    aclose ( poolfile ) ; 
	    Result = false ; 
	    goto lab10 ; 
	  } 
	  l = xord [ m ] * 10 + xord [ n ] - 48 * 11 ; 
	  if ( poolptr + l + stringvacancies > poolsize ) 
	  {
	    ; 
	    fprintf( termout , "%s\n",  "! You have to increase POOLSIZE." ) ; 
	    aclose ( poolfile ) ; 
	    Result = false ; 
	    goto lab10 ; 
	  } 
	  if ( strptr + stringsvacant >= maxstrings ) 
	  {
	    ; 
	    fprintf( termout , "%s\n",  "! You have to increase MAXSTRINGS." ) ; 
	    aclose ( poolfile ) ; 
	    Result = false ; 
	    goto lab10 ; 
	  } 
	  {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) 
	  do 
	    {
	      if ( eoln ( poolfile ) ) 
	      m = ' ' ; 
	      else read ( poolfile , m ) ; 
	      {
		strpool [ poolptr ] = xord [ m ] ; 
		incr ( poolptr ) ; 
	      } 
	    } 
	  while ( k++ < for_end ) ; } 
	  readln ( poolfile ) ; 
	  g = makestring () ; 
	  strref [ g ] = 127 ; 
	} 
      } 
    } while ( ! ( c ) ) ; 
    aclose ( poolfile ) ; 
    Result = true ; 
  } 
  else {
      
    ; 
    fprintf( termout , "%s\n",  "! I can't read mp.pool." ) ; 
    aclose ( poolfile ) ; 
    Result = false ; 
    goto lab10 ; 
  } 
  lastfixedstr = strptr - 1 ; 
  fixedstruse = strptr ; 
  lab10: ; 
  return(Result) ; 
} 
#endif /* INIMP */
#ifdef INIMP
void sortavail ( ) 
{halfword p, q, r  ; 
  halfword oldrover  ; 
  p = getnode ( 1073741824L ) ; 
  p = mem [ rover + 1 ] .hhfield .v.RH ; 
  mem [ rover + 1 ] .hhfield .v.RH = 65535L ; 
  oldrover = rover ; 
  while ( p != oldrover ) if ( p < rover ) 
  {
    q = p ; 
    p = mem [ q + 1 ] .hhfield .v.RH ; 
    mem [ q + 1 ] .hhfield .v.RH = rover ; 
    rover = q ; 
  } 
  else {
      
    q = rover ; 
    while ( mem [ q + 1 ] .hhfield .v.RH < p ) q = mem [ q + 1 ] .hhfield .v.RH ; 
    r = mem [ p + 1 ] .hhfield .v.RH ; 
    mem [ p + 1 ] .hhfield .v.RH = mem [ q + 1 ] .hhfield .v.RH ; 
    mem [ q + 1 ] .hhfield .v.RH = p ; 
    p = r ; 
  } 
  p = rover ; 
  while ( mem [ p + 1 ] .hhfield .v.RH != 65535L ) {
      
    mem [ mem [ p + 1 ] .hhfield .v.RH + 1 ] .hhfield .lhfield = p ; 
    p = mem [ p + 1 ] .hhfield .v.RH ; 
  } 
  mem [ p + 1 ] .hhfield .v.RH = rover ; 
  mem [ rover + 1 ] .hhfield .lhfield = p ; 
} 
#endif /* INIMP */
#ifdef INIMP
void zprimitive ( s , c , o ) 
strnumber s ; 
halfword c ; 
halfword o ; 
{poolpointer k  ; 
  smallnumber j  ; 
  smallnumber l  ; 
  k = strstart [ s ] ; 
  l = strstart [ nextstr [ s ] ] - k ; 
  {register integer for_end; j = 0 ; for_end = l - 1 ; if ( j <= for_end) do 
    buffer [ j ] = strpool [ k + j ] ; 
  while ( j++ < for_end ) ; } 
  cursym = idlookup ( 0 , l ) ; 
  if ( s >= 256 ) 
  {
    flushstring ( hash [ cursym ] .v.RH ) ; 
    hash [ cursym ] .v.RH = s ; 
  } 
  eqtb [ cursym ] .lhfield = c ; 
  eqtb [ cursym ] .v.RH = o ; 
} 
#endif /* INIMP */
#ifdef INIMP
void storememfile ( ) 
{/* 30 */ integer k  ; 
  halfword p, q  ; 
  integer x  ; 
  fourquarters w  ; 
  strnumber s  ; 
  selector = 10 ; 
  print ( 1177 ) ; 
  print ( jobname ) ; 
  printchar ( 32 ) ; 
  printint ( roundunscaled ( internal [ 13 ] ) % 100 ) ; 
  printchar ( 46 ) ; 
  printint ( roundunscaled ( internal [ 14 ] ) ) ; 
  printchar ( 46 ) ; 
  printint ( roundunscaled ( internal [ 15 ] ) ) ; 
  printchar ( 41 ) ; 
  if ( interaction == 0 ) 
  selector = 6 ; 
  else selector = 7 ; 
  {
    if ( poolptr + 1 > maxpoolptr ) 
    if ( poolptr + 1 > poolsize ) 
    docompaction ( 1 ) ; 
    else maxpoolptr = poolptr + 1 ; 
  } 
  memident = makestring () ; 
  strref [ memident ] = 127 ; 
  packjobname ( 785 ) ; 
  while ( ! wopenout ( memfile ) ) promptfilename ( 1178 , 785 ) ; 
  printnl ( 1179 ) ; 
  s = wmakenamestring ( memfile ) ; 
  print ( s ) ; 
  flushstring ( s ) ; 
  printnl ( memident ) ; 
  dumpint ( 473641430L ) ; 
  dumpint ( 0 ) ; 
  dumpint ( memtop ) ; 
  dumpint ( 2100 ) ; 
  dumpint ( 1777 ) ; 
  dumpint ( 15 ) ; 
  docompaction ( -1 ) ; 
  dumpint ( poolptr ) ; 
  dumpint ( maxstrptr ) ; 
  dumpint ( strptr ) ; 
  k = 0 ; 
  while ( ( nextstr [ k ] == k + 1 ) && ( k <= maxstrptr ) ) incr ( k ) ; 
  dumpint ( k ) ; 
  while ( k <= maxstrptr ) {
      
    dumpint ( nextstr [ k ] ) ; 
    incr ( k ) ; 
  } 
  k = 0 ; 
  while ( true ) {
      
    dumpint ( strstart [ k ] ) ; 
    if ( k == strptr ) 
    goto lab30 ; 
    else k = nextstr [ k ] ; 
  } 
  lab30: k = 0 ; 
  while ( k + 4 < poolptr ) {
      
    w .b0 = strpool [ k ] ; 
    w .b1 = strpool [ k + 1 ] ; 
    w .b2 = strpool [ k + 2 ] ; 
    w .b3 = strpool [ k + 3 ] ; 
    dumpqqqq ( w ) ; 
    k = k + 4 ; 
  } 
  k = poolptr - 4 ; 
  w .b0 = strpool [ k ] ; 
  w .b1 = strpool [ k + 1 ] ; 
  w .b2 = strpool [ k + 2 ] ; 
  w .b3 = strpool [ k + 3 ] ; 
  dumpqqqq ( w ) ; 
  println () ; 
  print ( 1173 ) ; 
  printint ( maxstrptr ) ; 
  print ( 1174 ) ; 
  printint ( poolptr ) ; 
  sortavail () ; 
  varused = 0 ; 
  dumpint ( lomemmax ) ; 
  dumpint ( rover ) ; 
  p = 0 ; 
  q = rover ; 
  x = 0 ; 
  do {
      { register integer for_end; k = p ; for_end = q + 1 ; if ( k <= 
    for_end) do 
      dumpwd ( mem [ k ] ) ; 
    while ( k++ < for_end ) ; } 
    x = x + q + 2 - p ; 
    varused = varused + q - p ; 
    p = q + mem [ q ] .hhfield .lhfield ; 
    q = mem [ q + 1 ] .hhfield .v.RH ; 
  } while ( ! ( q == rover ) ) ; 
  varused = varused + lomemmax - p ; 
  dynused = memend + 1 - himemmin ; 
  {register integer for_end; k = p ; for_end = lomemmax ; if ( k <= for_end) 
  do 
    dumpwd ( mem [ k ] ) ; 
  while ( k++ < for_end ) ; } 
  x = x + lomemmax + 1 - p ; 
  dumpint ( himemmin ) ; 
  dumpint ( avail ) ; 
  {register integer for_end; k = himemmin ; for_end = memend ; if ( k <= 
  for_end) do 
    dumpwd ( mem [ k ] ) ; 
  while ( k++ < for_end ) ; } 
  x = x + memend + 1 - himemmin ; 
  p = avail ; 
  while ( p != 0 ) {
      
    decr ( dynused ) ; 
    p = mem [ p ] .hhfield .v.RH ; 
  } 
  dumpint ( varused ) ; 
  dumpint ( dynused ) ; 
  println () ; 
  printint ( x ) ; 
  print ( 1175 ) ; 
  printint ( varused ) ; 
  printchar ( 38 ) ; 
  printint ( dynused ) ; 
  dumpint ( hashused ) ; 
  stcount = 2356 - hashused ; 
  {register integer for_end; p = 1 ; for_end = hashused ; if ( p <= for_end) 
  do 
    if ( hash [ p ] .v.RH != 0 ) 
    {
      dumpint ( p ) ; 
      dumphh ( hash [ p ] ) ; 
      dumphh ( eqtb [ p ] ) ; 
      incr ( stcount ) ; 
    } 
  while ( p++ < for_end ) ; } 
  {register integer for_end; p = hashused + 1 ; for_end = 2371 ; if ( p <= 
  for_end) do 
    {
      dumphh ( hash [ p ] ) ; 
      dumphh ( eqtb [ p ] ) ; 
    } 
  while ( p++ < for_end ) ; } 
  dumpint ( stcount ) ; 
  println () ; 
  printint ( stcount ) ; 
  print ( 1176 ) ; 
  dumpint ( intptr ) ; 
  {register integer for_end; k = 1 ; for_end = intptr ; if ( k <= for_end) do 
    {
      dumpint ( internal [ k ] ) ; 
      dumpint ( intname [ k ] ) ; 
    } 
  while ( k++ < for_end ) ; } 
  dumpint ( startsym ) ; 
  dumpint ( interaction ) ; 
  dumpint ( memident ) ; 
  dumpint ( bgloc ) ; 
  dumpint ( egloc ) ; 
  dumpint ( serialno ) ; 
  dumpint ( 69073L ) ; 
  internal [ 10 ] = 0 ; 
  wclose ( memfile ) ; 
} 
#endif /* INIMP */
void finalcleanup ( ) 
{/* 10 */ smallnumber c  ; 
  c = curmod ; 
  if ( jobname == 0 ) 
  openlogfile () ; 
  while ( inputptr > 0 ) if ( ( curinput .indexfield > 15 ) ) 
  endtokenlist () ; 
  else endfilereading () ; 
  while ( loopptr != 0 ) stopiteration () ; 
  while ( openparens > 0 ) {
      
    print ( 1181 ) ; 
    decr ( openparens ) ; 
  } 
  while ( condptr != 0 ) {
      
    printnl ( 1182 ) ; 
    printcmdmod ( 5 , curif ) ; 
    if ( ifline != 0 ) 
    {
      print ( 1183 ) ; 
      printint ( ifline ) ; 
    } 
    print ( 1184 ) ; 
    ifline = mem [ condptr + 1 ] .cint ; 
    curif = mem [ condptr ] .hhfield .b1 ; 
    condptr = mem [ condptr ] .hhfield .v.RH ; 
  } 
  if ( history != 0 ) 
  if ( ( ( history == 1 ) || ( interaction < 3 ) ) ) 
  if ( selector == 7 ) 
  {
    selector = 5 ; 
    printnl ( 1185 ) ; 
    selector = 7 ; 
  } 
  if ( c == 1 ) 
  {
	;
#ifdef INIMP
    storememfile () ; 
    goto lab10 ; 
#endif /* INIMP */
    printnl ( 1186 ) ; 
    goto lab10 ; 
  } 
  lab10: ; 
} 
#ifdef INIMP
void initprim ( ) 
{primitive ( 430 , 42 , 1 ) ; 
  primitive ( 431 , 42 , 2 ) ; 
  primitive ( 432 , 42 , 3 ) ; 
  primitive ( 433 , 42 , 4 ) ; 
  primitive ( 434 , 42 , 5 ) ; 
  primitive ( 435 , 42 , 6 ) ; 
  primitive ( 436 , 42 , 7 ) ; 
  primitive ( 437 , 42 , 8 ) ; 
  primitive ( 438 , 42 , 9 ) ; 
  primitive ( 439 , 42 , 10 ) ; 
  primitive ( 440 , 42 , 11 ) ; 
  primitive ( 441 , 42 , 12 ) ; 
  primitive ( 442 , 42 , 13 ) ; 
  primitive ( 443 , 42 , 14 ) ; 
  primitive ( 444 , 42 , 15 ) ; 
  primitive ( 445 , 42 , 16 ) ; 
  primitive ( 446 , 42 , 17 ) ; 
  primitive ( 447 , 42 , 18 ) ; 
  primitive ( 448 , 42 , 19 ) ; 
  primitive ( 449 , 42 , 20 ) ; 
  primitive ( 450 , 42 , 21 ) ; 
  primitive ( 451 , 42 , 22 ) ; 
  primitive ( 452 , 42 , 23 ) ; 
  primitive ( 453 , 42 , 24 ) ; 
  primitive ( 454 , 42 , 25 ) ; 
  primitive ( 455 , 42 , 26 ) ; 
  primitive ( 456 , 42 , 27 ) ; 
  primitive ( 457 , 42 , 28 ) ; 
  primitive ( 458 , 42 , 29 ) ; 
  primitive ( 459 , 42 , 30 ) ; 
  primitive ( 460 , 42 , 31 ) ; 
  primitive ( 461 , 42 , 32 ) ; 
  primitive ( 462 , 42 , 33 ) ; 
  primitive ( 322 , 49 , 0 ) ; 
  primitive ( 91 , 65 , 0 ) ; 
  eqtb [ 2360 ] = eqtb [ cursym ] ; 
  primitive ( 93 , 66 , 0 ) ; 
  primitive ( 125 , 67 , 0 ) ; 
  primitive ( 123 , 48 , 0 ) ; 
  primitive ( 58 , 80 , 0 ) ; 
  eqtb [ 2362 ] = eqtb [ cursym ] ; 
  primitive ( 474 , 79 , 0 ) ; 
  primitive ( 475 , 78 , 0 ) ; 
  primitive ( 476 , 76 , 0 ) ; 
  primitive ( 44 , 81 , 0 ) ; 
  primitive ( 59 , 82 , 0 ) ; 
  eqtb [ 2363 ] = eqtb [ cursym ] ; 
  primitive ( 92 , 10 , 0 ) ; 
  primitive ( 477 , 20 , 0 ) ; 
  primitive ( 478 , 61 , 0 ) ; 
  primitive ( 479 , 34 , 0 ) ; 
  bgloc = cursym ; 
  primitive ( 480 , 59 , 0 ) ; 
  primitive ( 481 , 62 , 0 ) ; 
  primitive ( 482 , 29 , 0 ) ; 
  primitive ( 468 , 83 , 0 ) ; 
  eqtb [ 2367 ] = eqtb [ cursym ] ; 
  egloc = cursym ; 
  primitive ( 483 , 28 , 0 ) ; 
  primitive ( 484 , 9 , 0 ) ; 
  primitive ( 485 , 12 , 0 ) ; 
  primitive ( 486 , 15 , 0 ) ; 
  primitive ( 487 , 16 , 0 ) ; 
  primitive ( 488 , 17 , 0 ) ; 
  primitive ( 489 , 70 , 0 ) ; 
  primitive ( 490 , 26 , 0 ) ; 
  primitive ( 491 , 14 , 0 ) ; 
  primitive ( 492 , 11 , 0 ) ; 
  primitive ( 493 , 19 , 0 ) ; 
  primitive ( 494 , 77 , 0 ) ; 
  primitive ( 495 , 30 , 0 ) ; 
  primitive ( 496 , 72 , 0 ) ; 
  primitive ( 497 , 37 , 0 ) ; 
  primitive ( 498 , 60 , 0 ) ; 
  primitive ( 499 , 71 , 0 ) ; 
  primitive ( 500 , 73 , 0 ) ; 
  primitive ( 501 , 74 , 0 ) ; 
  primitive ( 502 , 31 , 0 ) ; 
  primitive ( 682 , 1 , 0 ) ; 
  primitive ( 683 , 1 , 1 ) ; 
  primitive ( 465 , 2 , 0 ) ; 
  eqtb [ 2368 ] = eqtb [ cursym ] ; 
  primitive ( 466 , 3 , 0 ) ; 
  eqtb [ 2369 ] = eqtb [ cursym ] ; 
  primitive ( 696 , 18 , 1 ) ; 
  primitive ( 697 , 18 , 2 ) ; 
  primitive ( 698 , 18 , 55 ) ; 
  primitive ( 699 , 18 , 46 ) ; 
  primitive ( 700 , 18 , 51 ) ; 
  primitive ( 469 , 18 , 0 ) ; 
  eqtb [ 2365 ] = eqtb [ cursym ] ; 
  primitive ( 701 , 7 , 2372 ) ; 
  primitive ( 702 , 7 , 2522 ) ; 
  primitive ( 703 , 7 , 1 ) ; 
  primitive ( 470 , 7 , 0 ) ; 
  eqtb [ 2364 ] = eqtb [ cursym ] ; 
  primitive ( 704 , 63 , 0 ) ; 
  primitive ( 705 , 63 , 1 ) ; 
  primitive ( 64 , 63 , 2 ) ; 
  primitive ( 706 , 63 , 3 ) ; 
  primitive ( 717 , 58 , 2372 ) ; 
  primitive ( 718 , 58 , 2522 ) ; 
  primitive ( 719 , 58 , 2672 ) ; 
  primitive ( 720 , 58 , 1 ) ; 
  primitive ( 721 , 58 , 2 ) ; 
  primitive ( 722 , 58 , 3 ) ; 
  primitive ( 732 , 6 , 0 ) ; 
  primitive ( 629 , 6 , 1 ) ; 
  primitive ( 759 , 4 , 1 ) ; 
  primitive ( 467 , 5 , 2 ) ; 
  eqtb [ 2366 ] = eqtb [ cursym ] ; 
  primitive ( 760 , 5 , 3 ) ; 
  primitive ( 761 , 5 , 4 ) ; 
  primitive ( 348 , 35 , 30 ) ; 
  primitive ( 349 , 35 , 31 ) ; 
  primitive ( 350 , 35 , 32 ) ; 
  primitive ( 351 , 35 , 33 ) ; 
  primitive ( 352 , 35 , 34 ) ; 
  primitive ( 353 , 35 , 35 ) ; 
  primitive ( 354 , 35 , 36 ) ; 
  primitive ( 355 , 35 , 37 ) ; 
  primitive ( 356 , 36 , 38 ) ; 
  primitive ( 357 , 36 , 39 ) ; 
  primitive ( 358 , 36 , 40 ) ; 
  primitive ( 359 , 36 , 41 ) ; 
  primitive ( 360 , 36 , 42 ) ; 
  primitive ( 361 , 36 , 43 ) ; 
  primitive ( 362 , 36 , 44 ) ; 
  primitive ( 363 , 36 , 45 ) ; 
  primitive ( 364 , 36 , 46 ) ; 
  primitive ( 365 , 36 , 47 ) ; 
  primitive ( 366 , 36 , 48 ) ; 
  primitive ( 367 , 36 , 49 ) ; 
  primitive ( 368 , 36 , 50 ) ; 
  primitive ( 369 , 36 , 51 ) ; 
  primitive ( 370 , 36 , 52 ) ; 
  primitive ( 371 , 36 , 53 ) ; 
  primitive ( 372 , 36 , 54 ) ; 
  primitive ( 373 , 36 , 55 ) ; 
  primitive ( 374 , 36 , 56 ) ; 
  primitive ( 375 , 36 , 57 ) ; 
  primitive ( 376 , 36 , 58 ) ; 
  primitive ( 377 , 36 , 59 ) ; 
  primitive ( 378 , 36 , 60 ) ; 
  primitive ( 379 , 36 , 61 ) ; 
  primitive ( 380 , 36 , 62 ) ; 
  primitive ( 381 , 36 , 63 ) ; 
  primitive ( 382 , 36 , 64 ) ; 
  primitive ( 383 , 36 , 65 ) ; 
  primitive ( 384 , 36 , 66 ) ; 
  primitive ( 385 , 36 , 67 ) ; 
  primitive ( 386 , 36 , 68 ) ; 
  primitive ( 387 , 36 , 69 ) ; 
  primitive ( 388 , 36 , 70 ) ; 
  primitive ( 389 , 36 , 71 ) ; 
  primitive ( 390 , 36 , 72 ) ; 
  primitive ( 391 , 36 , 73 ) ; 
  primitive ( 392 , 36 , 74 ) ; 
  primitive ( 393 , 36 , 75 ) ; 
  primitive ( 394 , 36 , 76 ) ; 
  primitive ( 395 , 36 , 77 ) ; 
  primitive ( 396 , 36 , 78 ) ; 
  primitive ( 397 , 36 , 79 ) ; 
  primitive ( 398 , 36 , 80 ) ; 
  primitive ( 399 , 36 , 81 ) ; 
  primitive ( 400 , 38 , 82 ) ; 
  primitive ( 402 , 36 , 84 ) ; 
  primitive ( 401 , 36 , 83 ) ; 
  primitive ( 403 , 36 , 85 ) ; 
  primitive ( 404 , 36 , 86 ) ; 
  primitive ( 405 , 36 , 87 ) ; 
  primitive ( 43 , 45 , 88 ) ; 
  primitive ( 45 , 45 , 89 ) ; 
  primitive ( 42 , 57 , 90 ) ; 
  primitive ( 47 , 56 , 91 ) ; 
  eqtb [ 2361 ] = eqtb [ cursym ] ; 
  primitive ( 406 , 47 , 92 ) ; 
  primitive ( 311 , 47 , 93 ) ; 
  primitive ( 407 , 47 , 94 ) ; 
  primitive ( 408 , 54 , 95 ) ; 
  primitive ( 60 , 52 , 96 ) ; 
  primitive ( 409 , 52 , 97 ) ; 
  primitive ( 62 , 52 , 98 ) ; 
  primitive ( 410 , 52 , 99 ) ; 
  primitive ( 61 , 53 , 100 ) ; 
  primitive ( 411 , 52 , 101 ) ; 
  primitive ( 422 , 39 , 114 ) ; 
  primitive ( 423 , 39 , 115 ) ; 
  primitive ( 424 , 39 , 116 ) ; 
  primitive ( 425 , 39 , 117 ) ; 
  primitive ( 426 , 39 , 118 ) ; 
  primitive ( 427 , 39 , 119 ) ; 
  primitive ( 428 , 39 , 120 ) ; 
  primitive ( 429 , 39 , 121 ) ; 
  primitive ( 38 , 50 , 102 ) ; 
  primitive ( 412 , 57 , 103 ) ; 
  primitive ( 413 , 57 , 104 ) ; 
  primitive ( 414 , 57 , 105 ) ; 
  primitive ( 415 , 57 , 106 ) ; 
  primitive ( 416 , 57 , 107 ) ; 
  primitive ( 417 , 57 , 108 ) ; 
  primitive ( 418 , 57 , 109 ) ; 
  primitive ( 419 , 57 , 110 ) ; 
  primitive ( 420 , 57 , 111 ) ; 
  primitive ( 421 , 47 , 112 ) ; 
  primitive ( 341 , 32 , 15 ) ; 
  primitive ( 260 , 32 , 4 ) ; 
  primitive ( 326 , 32 , 2 ) ; 
  primitive ( 331 , 32 , 8 ) ; 
  primitive ( 329 , 32 , 6 ) ; 
  primitive ( 333 , 32 , 10 ) ; 
  primitive ( 335 , 32 , 12 ) ; 
  primitive ( 336 , 32 , 13 ) ; 
  primitive ( 337 , 32 , 14 ) ; 
  primitive ( 960 , 84 , 0 ) ; 
  primitive ( 961 , 84 , 1 ) ; 
  primitive ( 273 , 25 , 0 ) ; 
  primitive ( 274 , 25 , 1 ) ; 
  primitive ( 275 , 25 , 2 ) ; 
  primitive ( 967 , 25 , 3 ) ; 
  primitive ( 968 , 23 , 0 ) ; 
  primitive ( 969 , 23 , 1 ) ; 
  primitive ( 983 , 24 , 0 ) ; 
  primitive ( 984 , 24 , 1 ) ; 
  primitive ( 985 , 24 , 2 ) ; 
  primitive ( 986 , 24 , 3 ) ; 
  primitive ( 987 , 24 , 4 ) ; 
  primitive ( 1006 , 69 , 0 ) ; 
  primitive ( 1007 , 69 , 1 ) ; 
  primitive ( 1008 , 69 , 2 ) ; 
  primitive ( 1009 , 68 , 6 ) ; 
  primitive ( 1010 , 68 , 10 ) ; 
  primitive ( 1011 , 68 , 13 ) ; 
  primitive ( 1020 , 21 , 4 ) ; 
  primitive ( 1021 , 21 , 5 ) ; 
  primitive ( 1034 , 27 , 0 ) ; 
  primitive ( 1035 , 27 , 1 ) ; 
  primitive ( 1036 , 27 , 2 ) ; 
  primitive ( 1051 , 22 , 0 ) ; 
  primitive ( 1052 , 22 , 1 ) ; 
  primitive ( 1053 , 22 , 2 ) ; 
  primitive ( 1054 , 22 , 3 ) ; 
  primitive ( 1055 , 22 , 4 ) ; 
  primitive ( 1073 , 75 , 0 ) ; 
  primitive ( 1074 , 75 , 1 ) ; 
  primitive ( 1075 , 75 , 5 ) ; 
  primitive ( 1076 , 75 , 2 ) ; 
  primitive ( 1077 , 75 , 6 ) ; 
  primitive ( 1078 , 75 , 3 ) ; 
  primitive ( 1079 , 75 , 7 ) ; 
  primitive ( 1080 , 75 , 11 ) ; 
  primitive ( 1081 , 75 , 128 ) ; 
} 
void inittab ( ) 
{integer k  ; 
  rover = 24 ; 
  mem [ rover ] .hhfield .v.RH = 65535L ; 
  mem [ rover ] .hhfield .lhfield = 1000 ; 
  mem [ rover + 1 ] .hhfield .lhfield = rover ; 
  mem [ rover + 1 ] .hhfield .v.RH = rover ; 
  lomemmax = rover + 1000 ; 
  mem [ lomemmax ] .hhfield .v.RH = 0 ; 
  mem [ lomemmax ] .hhfield .lhfield = 0 ; 
  {register integer for_end; k = memtop - 3 ; for_end = memtop ; if ( k <= 
  for_end) do 
    mem [ k ] = mem [ lomemmax ] ; 
  while ( k++ < for_end ) ; } 
  avail = 0 ; 
  memend = memtop ; 
  himemmin = memtop - 3 ; 
  varused = 24 ; 
  dynused = memtop + 1 - ( memtop - 3 ) ; 
  mem [ 14 ] .cint = -32768L ; 
  mem [ 15 ] .cint = 0 ; 
  mem [ 17 ] .cint = 32768L ; 
  mem [ 18 ] .cint = 0 ; 
  mem [ 20 ] .cint = 0 ; 
  mem [ 21 ] .cint = 65536L ; 
  mem [ 13 ] .hhfield .v.RH = 16 ; 
  mem [ 16 ] .hhfield .v.RH = 19 ; 
  mem [ 19 ] .hhfield .v.RH = 13 ; 
  mem [ 13 ] .hhfield .lhfield = 19 ; 
  mem [ 16 ] .hhfield .lhfield = 13 ; 
  mem [ 19 ] .hhfield .lhfield = 16 ; 
  intname [ 1 ] = 430 ; 
  intname [ 2 ] = 431 ; 
  intname [ 3 ] = 432 ; 
  intname [ 4 ] = 433 ; 
  intname [ 5 ] = 434 ; 
  intname [ 6 ] = 435 ; 
  intname [ 7 ] = 436 ; 
  intname [ 8 ] = 437 ; 
  intname [ 9 ] = 438 ; 
  intname [ 10 ] = 439 ; 
  intname [ 11 ] = 440 ; 
  intname [ 12 ] = 441 ; 
  intname [ 13 ] = 442 ; 
  intname [ 14 ] = 443 ; 
  intname [ 15 ] = 444 ; 
  intname [ 16 ] = 445 ; 
  intname [ 17 ] = 446 ; 
  intname [ 18 ] = 447 ; 
  intname [ 19 ] = 448 ; 
  intname [ 20 ] = 449 ; 
  intname [ 21 ] = 450 ; 
  intname [ 22 ] = 451 ; 
  intname [ 23 ] = 452 ; 
  intname [ 24 ] = 453 ; 
  intname [ 25 ] = 454 ; 
  intname [ 26 ] = 455 ; 
  intname [ 27 ] = 456 ; 
  intname [ 28 ] = 457 ; 
  intname [ 29 ] = 458 ; 
  intname [ 30 ] = 459 ; 
  intname [ 31 ] = 460 ; 
  intname [ 32 ] = 461 ; 
  intname [ 33 ] = 462 ; 
  hashused = 2357 ; 
  stcount = 0 ; 
  hash [ 2370 ] .v.RH = 464 ; 
  hash [ 2368 ] .v.RH = 465 ; 
  hash [ 2369 ] .v.RH = 466 ; 
  hash [ 2366 ] .v.RH = 467 ; 
  hash [ 2367 ] .v.RH = 468 ; 
  hash [ 2365 ] .v.RH = 469 ; 
  hash [ 2364 ] .v.RH = 470 ; 
  hash [ 2363 ] .v.RH = 59 ; 
  hash [ 2362 ] .v.RH = 58 ; 
  hash [ 2361 ] .v.RH = 47 ; 
  hash [ 2360 ] .v.RH = 91 ; 
  hash [ 2359 ] .v.RH = 41 ; 
  hash [ 2357 ] .v.RH = 471 ; 
  eqtb [ 2359 ] .lhfield = 64 ; 
  mem [ 0 ] .hhfield .v.RH = 0 ; 
  mem [ 1 ] .cint = 0 ; 
  mem [ 11 ] .hhfield .lhfield = 2372 ; 
  mem [ 11 ] .hhfield .v.RH = 0 ; 
  serialno = 0 ; 
  mem [ 5 ] .hhfield .v.RH = 5 ; 
  mem [ 6 ] .hhfield .lhfield = 5 ; 
  mem [ 5 ] .hhfield .lhfield = 0 ; 
  mem [ 6 ] .hhfield .v.RH = 0 ; 
  mem [ 22 ] .hhfield .b1 = 0 ; 
  mem [ 22 ] .hhfield .v.RH = 2370 ; 
  eqtb [ 2370 ] .v.RH = 22 ; 
  eqtb [ 2370 ] .lhfield = 43 ; 
  eqtb [ 2358 ] .lhfield = 93 ; 
  hash [ 2358 ] .v.RH = 776 ; 
  mem [ 9 ] .hhfield .b1 = 14 ; 
  mem [ 12 ] .cint = 1073741824L ; 
  mem [ 8 ] .cint = 0 ; 
  mem [ 7 ] .hhfield .lhfield = 0 ; 
  fontdsize [ 0 ] = 0 ; 
  fontname [ 0 ] = 285 ; 
  fontpsname [ 0 ] = 285 ; 
  fontbc [ 0 ] = 1 ; 
  fontec [ 0 ] = 0 ; 
  charbase [ 0 ] = 0 ; 
  widthbase [ 0 ] = 0 ; 
  heightbase [ 0 ] = 0 ; 
  depthbase [ 0 ] = 0 ; 
  nextfmem = 0 ; 
  lastfnum = 0 ; 
  lastpsfnum = 0 ; 
} 
#endif /* INIMP */
void main_body() {
    
  history = 3 ; 
  termout = stdout ; 
  setpaths () ; 
  if ( readyalready == 314159L ) 
  goto lab1 ; 
  bad = 0 ; 
  if ( ( halferrorline < 30 ) || ( halferrorline > errorline - 15 ) ) 
  bad = 1 ; 
  if ( maxprintline < 60 ) 
  bad = 2 ; 
  if ( emergencylinelength < maxprintline ) 
  bad = 3 ; 
  if ( 1100 > memtop ) 
  bad = 4 ; 
  if ( 1777 > 2100 ) 
  bad = 5 ; 
  if ( headersize % 4 != 0 ) 
  bad = 6 ; 
  if ( ( ligtablesize < 255 ) || ( ligtablesize > 32510 ) ) 
  bad = 7 ; 
#ifdef INIMP
  if ( memmax != memtop ) 
  bad = 8 ; 
#endif /* INIMP */
  if ( memmax < memtop ) 
  bad = 8 ; 
  if ( ( 0 > 0 ) || ( 255 < 127 ) ) 
  bad = 9 ; 
  if ( ( 0 > 0 ) || ( 65535L < 32767 ) ) 
  bad = 10 ; 
  if ( ( 0 < 0 ) || ( 255 > 65535L ) ) 
  bad = 11 ; 
  if ( ( 0 < 0 ) || ( memmax >= 65535L ) ) 
  bad = 12 ; 
  if ( maxstrings > 65535L ) 
  bad = 13 ; 
  if ( bufsize > 65535L ) 
  bad = 14 ; 
  if ( fontmax > 65535L ) 
  bad = 15 ; 
  if ( ( 255 < 255 ) || ( 65535L < 65535L ) ) 
  bad = 16 ; 
  if ( 2371 + maxinternal > 65535L ) 
  bad = 17 ; 
  if ( 2822 > 65535L ) 
  bad = 18 ; 
  if ( 20 + 17 * 45 > bistacksize ) 
  bad = 19 ; 
  if ( 9 > filenamesize ) 
  bad = 20 ; 
  if ( bad > 0 ) 
  {
    fprintf( termout , "%s%s%ld\n",  "Ouch---my internal constants have been clobbered!" ,     "---case " , (long)bad ) ; 
    goto lab9999 ; 
  } 
  initialize () ; 
#ifdef INIMP
  if ( ! getstringsstarted () ) 
  goto lab9999 ; 
  inittab () ; 
  initprim () ; 
  initstruse = strptr ; 
  initpoolptr = poolptr ; 
  maxstrptr = strptr ; 
  maxpoolptr = poolptr ; 
  fixdateandtime () ; 
#endif /* INIMP */
  readyalready = 314159L ; 
  lab1: selector = 5 ; 
  tally = 0 ; 
  termoffset = 0 ; 
  fileoffset = 0 ; 
  psoffset = 0 ; 
  flush ( termout ) ; 
  jobname = 0 ; 
  logopened = false ; 
  {
    {
      inputptr = 0 ; 
      maxinstack = 0 ; 
      inopen = 0 ; 
      openparens = 0 ; 
      maxbufstack = 0 ; 
      paramptr = 0 ; 
      maxparamstack = 0 ; 
      first = 1 ; 
      curinput .startfield = 1 ; 
      curinput .indexfield = 0 ; 
      linestack [ curinput .indexfield ] = 0 ; 
      curinput .namefield = 0 ; 
      mpxname [ 0 ] = 1 ; 
      forceeof = false ; 
      if ( ! initterminal () ) 
      goto lab9999 ; 
      curinput .limitfield = last ; 
      first = last + 1 ; 
    } 
    scannerstatus = 0 ; 
    if ( ( memident == 0 ) || ( buffer [ curinput .locfield ] == 38 ) ) 
    {
      if ( memident != 0 ) 
      initialize () ; 
      if ( ! openmemfile () ) 
      goto lab9999 ; 
      if ( ! loadmemfile () ) 
      {
	wclose ( memfile ) ; 
	goto lab9999 ; 
      } 
      wclose ( memfile ) ; 
      while ( ( curinput .locfield < curinput .limitfield ) && ( buffer [ 
      curinput .locfield ] == 32 ) ) incr ( curinput .locfield ) ; 
    } 
    buffer [ curinput .limitfield ] = 37 ; 
    fixdateandtime () ; 
    initrandoms ( ( internal [ 16 ] / 65536L ) + internal [ 15 ] ) ; 
    if ( interaction == 0 ) 
    selector = 4 ; 
    else selector = 5 ; 
    if ( curinput .locfield < curinput .limitfield ) 
    if ( buffer [ curinput .locfield ] != 92 ) 
    startinput () ; 
  } 
  if ( troffmode ) 
  internal [ 32 ] = 65536L ; 
  history = 0 ; 
  if ( startsym > 0 ) 
  {
    cursym = startsym ; 
    backinput () ; 
  } 
  maincontrol () ; 
  finalcleanup () ; 
  closefilesandterminate () ; 
  lab9999: readyalready = 0 ; 
  if ( ( history != 0 ) && ( history != 1 ) ) 
  uexit ( 1 ) ; 
  else uexit ( 0 ) ; 
}