#define EXTERN extern
#include "mpd.h"

void initialize ( ) 
{integer i  ; 
  integer k  ; 
  xchr [ 32 ] = ' ' ; 
  xchr [ 33 ] = '!' ; 
  xchr [ 34 ] = '"' ; 
  xchr [ 35 ] = '#' ; 
  xchr [ 36 ] = '$' ; 
  xchr [ 37 ] = '%' ; 
  xchr [ 38 ] = '&' ; 
  xchr [ 39 ] = '\'' ; 
  xchr [ 40 ] = '(' ; 
  xchr [ 41 ] = ')' ; 
  xchr [ 42 ] = '*' ; 
  xchr [ 43 ] = '+' ; 
  xchr [ 44 ] = ',' ; 
  xchr [ 45 ] = '-' ; 
  xchr [ 46 ] = '.' ; 
  xchr [ 47 ] = '/' ; 
  xchr [ 48 ] = '0' ; 
  xchr [ 49 ] = '1' ; 
  xchr [ 50 ] = '2' ; 
  xchr [ 51 ] = '3' ; 
  xchr [ 52 ] = '4' ; 
  xchr [ 53 ] = '5' ; 
  xchr [ 54 ] = '6' ; 
  xchr [ 55 ] = '7' ; 
  xchr [ 56 ] = '8' ; 
  xchr [ 57 ] = '9' ; 
  xchr [ 58 ] = ':' ; 
  xchr [ 59 ] = ';' ; 
  xchr [ 60 ] = '<' ; 
  xchr [ 61 ] = '=' ; 
  xchr [ 62 ] = '>' ; 
  xchr [ 63 ] = '?' ; 
  xchr [ 64 ] = '@' ; 
  xchr [ 65 ] = 'A' ; 
  xchr [ 66 ] = 'B' ; 
  xchr [ 67 ] = 'C' ; 
  xchr [ 68 ] = 'D' ; 
  xchr [ 69 ] = 'E' ; 
  xchr [ 70 ] = 'F' ; 
  xchr [ 71 ] = 'G' ; 
  xchr [ 72 ] = 'H' ; 
  xchr [ 73 ] = 'I' ; 
  xchr [ 74 ] = 'J' ; 
  xchr [ 75 ] = 'K' ; 
  xchr [ 76 ] = 'L' ; 
  xchr [ 77 ] = 'M' ; 
  xchr [ 78 ] = 'N' ; 
  xchr [ 79 ] = 'O' ; 
  xchr [ 80 ] = 'P' ; 
  xchr [ 81 ] = 'Q' ; 
  xchr [ 82 ] = 'R' ; 
  xchr [ 83 ] = 'S' ; 
  xchr [ 84 ] = 'T' ; 
  xchr [ 85 ] = 'U' ; 
  xchr [ 86 ] = 'V' ; 
  xchr [ 87 ] = 'W' ; 
  xchr [ 88 ] = 'X' ; 
  xchr [ 89 ] = 'Y' ; 
  xchr [ 90 ] = 'Z' ; 
  xchr [ 91 ] = '[' ; 
  xchr [ 92 ] = '\\' ; 
  xchr [ 93 ] = ']' ; 
  xchr [ 94 ] = '^' ; 
  xchr [ 95 ] = '_' ; 
  xchr [ 96 ] = '`' ; 
  xchr [ 97 ] = 'a' ; 
  xchr [ 98 ] = 'b' ; 
  xchr [ 99 ] = 'c' ; 
  xchr [ 100 ] = 'd' ; 
  xchr [ 101 ] = 'e' ; 
  xchr [ 102 ] = 'f' ; 
  xchr [ 103 ] = 'g' ; 
  xchr [ 104 ] = 'h' ; 
  xchr [ 105 ] = 'i' ; 
  xchr [ 106 ] = 'j' ; 
  xchr [ 107 ] = 'k' ; 
  xchr [ 108 ] = 'l' ; 
  xchr [ 109 ] = 'm' ; 
  xchr [ 110 ] = 'n' ; 
  xchr [ 111 ] = 'o' ; 
  xchr [ 112 ] = 'p' ; 
  xchr [ 113 ] = 'q' ; 
  xchr [ 114 ] = 'r' ; 
  xchr [ 115 ] = 's' ; 
  xchr [ 116 ] = 't' ; 
  xchr [ 117 ] = 'u' ; 
  xchr [ 118 ] = 'v' ; 
  xchr [ 119 ] = 'w' ; 
  xchr [ 120 ] = 'x' ; 
  xchr [ 121 ] = 'y' ; 
  xchr [ 122 ] = 'z' ; 
  xchr [ 123 ] = '{' ; 
  xchr [ 124 ] = '|' ; 
  xchr [ 125 ] = '}' ; 
  xchr [ 126 ] = '~' ; 
  {register integer for_end; i = 0 ; for_end = 31 ; if ( i <= for_end) do 
    xchr [ i ] = ' ' ; 
  while ( i++ < for_end ) ; } 
  {register integer for_end; i = 127 ; for_end = 255 ; if ( i <= for_end) do 
    xchr [ i ] = ' ' ; 
  while ( i++ < for_end ) ; } 
  xchr [ 9 ] = chr ( 9 ) ; 
  xchr [ 12 ] = chr ( 12 ) ; 
  {register integer for_end; i = 0 ; for_end = 255 ; if ( i <= for_end) do 
    xord [ chr ( i ) ] = 127 ; 
  while ( i++ < for_end ) ; } 
  {register integer for_end; i = 128 ; for_end = 255 ; if ( i <= for_end) do 
    xord [ xchr [ i ] ] = i ; 
  while ( i++ < for_end ) ; } 
  {register integer for_end; i = 0 ; for_end = 126 ; if ( i <= for_end) do 
    xord [ xchr [ i ] ] = i ; 
  while ( i++ < for_end ) ; } 
  interaction = 3 ; 
  deletionsallowed = true ; 
  errorcount = 0 ; 
  helpptr = 0 ; 
  useerrhelp = false ; 
  errhelp = 0 ; 
  interrupt = 0 ; 
  OKtointerrupt = true ; 
  aritherror = false ; 
  twotothe [ 0 ] = 1 ; 
  {register integer for_end; k = 1 ; for_end = 30 ; if ( k <= for_end) do 
    twotothe [ k ] = 2 * twotothe [ k - 1 ] ; 
  while ( k++ < for_end ) ; } 
  speclog [ 1 ] = 93032640L ; 
  speclog [ 2 ] = 38612034L ; 
  speclog [ 3 ] = 17922280L ; 
  speclog [ 4 ] = 8662214L ; 
  speclog [ 5 ] = 4261238L ; 
  speclog [ 6 ] = 2113709L ; 
  speclog [ 7 ] = 1052693L ; 
  speclog [ 8 ] = 525315L ; 
  speclog [ 9 ] = 262400L ; 
  speclog [ 10 ] = 131136L ; 
  speclog [ 11 ] = 65552L ; 
  speclog [ 12 ] = 32772L ; 
  speclog [ 13 ] = 16385 ; 
  {register integer for_end; k = 14 ; for_end = 27 ; if ( k <= for_end) do 
    speclog [ k ] = twotothe [ 27 - k ] ; 
  while ( k++ < for_end ) ; } 
  speclog [ 28 ] = 1 ; 
  specatan [ 1 ] = 27855475L ; 
  specatan [ 2 ] = 14718068L ; 
  specatan [ 3 ] = 7471121L ; 
  specatan [ 4 ] = 3750058L ; 
  specatan [ 5 ] = 1876857L ; 
  specatan [ 6 ] = 938658L ; 
  specatan [ 7 ] = 469357L ; 
  specatan [ 8 ] = 234682L ; 
  specatan [ 9 ] = 117342L ; 
  specatan [ 10 ] = 58671L ; 
  specatan [ 11 ] = 29335 ; 
  specatan [ 12 ] = 14668 ; 
  specatan [ 13 ] = 7334 ; 
  specatan [ 14 ] = 3667 ; 
  specatan [ 15 ] = 1833 ; 
  specatan [ 16 ] = 917 ; 
  specatan [ 17 ] = 458 ; 
  specatan [ 18 ] = 229 ; 
  specatan [ 19 ] = 115 ; 
  specatan [ 20 ] = 57 ; 
  specatan [ 21 ] = 29 ; 
  specatan [ 22 ] = 14 ; 
  specatan [ 23 ] = 7 ; 
  specatan [ 24 ] = 4 ; 
  specatan [ 25 ] = 2 ; 
  specatan [ 26 ] = 1 ; 
	;
#ifdef DEBUG
  wasmemend = 0 ; 
  waslomax = 0 ; 
  washimin = memmax ; 
  panicking = false ; 
#endif /* DEBUG */
  {register integer for_end; k = 1 ; for_end = 33 ; if ( k <= for_end) do 
    internal [ k ] = 0 ; 
  while ( k++ < for_end ) ; } 
  intptr = 33 ; 
  {register integer for_end; k = 48 ; for_end = 57 ; if ( k <= for_end) do 
    charclass [ k ] = 0 ; 
  while ( k++ < for_end ) ; } 
  charclass [ 46 ] = 1 ; 
  charclass [ 32 ] = 2 ; 
  charclass [ 37 ] = 3 ; 
  charclass [ 34 ] = 4 ; 
  charclass [ 44 ] = 5 ; 
  charclass [ 59 ] = 6 ; 
  charclass [ 40 ] = 7 ; 
  charclass [ 41 ] = 8 ; 
  {register integer for_end; k = 65 ; for_end = 90 ; if ( k <= for_end) do 
    charclass [ k ] = 9 ; 
  while ( k++ < for_end ) ; } 
  {register integer for_end; k = 97 ; for_end = 122 ; if ( k <= for_end) do 
    charclass [ k ] = 9 ; 
  while ( k++ < for_end ) ; } 
  charclass [ 95 ] = 9 ; 
  charclass [ 60 ] = 10 ; 
  charclass [ 61 ] = 10 ; 
  charclass [ 62 ] = 10 ; 
  charclass [ 58 ] = 10 ; 
  charclass [ 124 ] = 10 ; 
  charclass [ 96 ] = 11 ; 
  charclass [ 39 ] = 11 ; 
  charclass [ 43 ] = 12 ; 
  charclass [ 45 ] = 12 ; 
  charclass [ 47 ] = 13 ; 
  charclass [ 42 ] = 13 ; 
  charclass [ 92 ] = 13 ; 
  charclass [ 33 ] = 14 ; 
  charclass [ 63 ] = 14 ; 
  charclass [ 35 ] = 15 ; 
  charclass [ 38 ] = 15 ; 
  charclass [ 64 ] = 15 ; 
  charclass [ 36 ] = 15 ; 
  charclass [ 94 ] = 16 ; 
  charclass [ 126 ] = 16 ; 
  charclass [ 91 ] = 17 ; 
  charclass [ 93 ] = 18 ; 
  charclass [ 123 ] = 19 ; 
  charclass [ 125 ] = 19 ; 
  {register integer for_end; k = 0 ; for_end = 31 ; if ( k <= for_end) do 
    charclass [ k ] = 20 ; 
  while ( k++ < for_end ) ; } 
  charclass [ 9 ] = 2 ; 
  charclass [ 12 ] = 2 ; 
  {register integer for_end; k = 127 ; for_end = 255 ; if ( k <= for_end) do 
    charclass [ k ] = 20 ; 
  while ( k++ < for_end ) ; } 
  hash [ 1 ] .lhfield = 0 ; 
  hash [ 1 ] .v.RH = 0 ; 
  eqtb [ 1 ] .lhfield = 43 ; 
  eqtb [ 1 ] .v.RH = 0 ; 
  {register integer for_end; k = 2 ; for_end = 2371 ; if ( k <= for_end) do 
    {
      hash [ k ] = hash [ 1 ] ; 
      eqtb [ k ] = eqtb [ 1 ] ; 
    } 
  while ( k++ < for_end ) ; } 
  bignodesize [ 12 ] = 12 ; 
  bignodesize [ 14 ] = 4 ; 
  bignodesize [ 13 ] = 6 ; 
  sector0 [ 12 ] = 5 ; 
  sector0 [ 14 ] = 5 ; 
  sector0 [ 13 ] = 11 ; 
  {register integer for_end; k = 5 ; for_end = 10 ; if ( k <= for_end) do 
    sectoroffset [ k ] = 2 * ( k - 5 ) ; 
  while ( k++ < for_end ) ; } 
  {register integer for_end; k = 11 ; for_end = 13 ; if ( k <= for_end) do 
    sectoroffset [ k ] = 2 * ( k - 11 ) ; 
  while ( k++ < for_end ) ; } 
  saveptr = 0 ; 
  halfcos [ 0 ] = 134217728L ; 
  halfcos [ 1 ] = 94906266L ; 
  halfcos [ 2 ] = 0 ; 
  dcos [ 0 ] = 35596755L ; 
  dcos [ 1 ] = 25170707L ; 
  dcos [ 2 ] = 0 ; 
  {register integer for_end; k = 3 ; for_end = 4 ; if ( k <= for_end) do 
    {
      halfcos [ k ] = - (integer) halfcos [ 4 - k ] ; 
      dcos [ k ] = - (integer) dcos [ 4 - k ] ; 
    } 
  while ( k++ < for_end ) ; } 
  {register integer for_end; k = 5 ; for_end = 7 ; if ( k <= for_end) do 
    {
      halfcos [ k ] = halfcos [ 8 - k ] ; 
      dcos [ k ] = dcos [ 8 - k ] ; 
    } 
  while ( k++ < for_end ) ; } 
  grobjectsize [ 1 ] = 6 ; 
  grobjectsize [ 2 ] = 8 ; 
  grobjectsize [ 3 ] = 14 ; 
  grobjectsize [ 4 ] = 2 ; 
  grobjectsize [ 6 ] = 2 ; 
  grobjectsize [ 5 ] = 2 ; 
  grobjectsize [ 7 ] = 2 ; 
  specp1 = 0 ; 
  specp2 = 0 ; 
  fixneeded = false ; 
  watchcoefs = true ; 
  condptr = 0 ; 
  iflimit = 0 ; 
  curif = 0 ; 
  ifline = 0 ; 
  loopptr = 0 ; 
  curname = 285 ; 
  curarea = 285 ; 
  curext = 285 ; 
  troffmode = false ; 
  (void) strcpy(MPmemdefault + 1, "plain.mem") ; 
  readfiles = 0 ; 
  writefiles = 0 ; 
  curexp = 0 ; 
  varflag = 0 ; 
  eofline = 0 ; 
  startsym = 0 ; 
  longhelpseen = false ; 
  {register integer for_end; k = 0 ; for_end = 255 ; if ( k <= for_end) do 
    {
      tfmwidth [ k ] = 0 ; 
      tfmheight [ k ] = 0 ; 
      tfmdepth [ k ] = 0 ; 
      tfmitalcorr [ k ] = 0 ; 
      charexists [ k ] = false ; 
      chartag [ k ] = 0 ; 
      charremainder [ k ] = 0 ; 
      skiptable [ k ] = ligtablesize ; 
    } 
  while ( k++ < for_end ) ; } 
  {register integer for_end; k = 1 ; for_end = headersize ; if ( k <= 
  for_end) do 
    headerbyte [ k ] = -1 ; 
  while ( k++ < for_end ) ; } 
  bc = 255 ; 
  ec = 0 ; 
  nl = 0 ; 
  nk = 0 ; 
  ne = 0 ; 
  np = 0 ; 
  internal [ 31 ] = -65536L ; 
  bchlabel = ligtablesize ; 
  labelloc [ 0 ] = -1 ; 
  labelptr = 0 ; 
  firstfilename = 285 ; 
  lastfilename = 285 ; 
  firstoutputcode = 32768L ; 
  lastoutputcode = -32768L ; 
  totalshipped = 0 ; 
  lastpending = memtop - 3 ; 
  memident = 0 ; 
  editnamestart = 0 ; 
} 
void println ( ) 
{switch ( selector ) 
  {case 7 : 
    {
      putc ('\n',  termout );
      putc ('\n',  logfile );
      termoffset = 0 ; 
      fileoffset = 0 ; 
    } 
    break ; 
  case 6 : 
    {
      putc ('\n',  logfile );
      fileoffset = 0 ; 
    } 
    break ; 
  case 5 : 
    {
      putc ('\n',  termout );
      termoffset = 0 ; 
    } 
    break ; 
  case 8 : 
    {
      putc ('\n',  psfile );
      psoffset = 0 ; 
    } 
    break ; 
  case 4 : 
  case 9 : 
  case 10 : 
    ; 
    break ; 
    default: 
    putc ('\n',  wrfile [ selector ] );
    break ; 
  } 
} 
void zprintchar ( s ) 
ASCIIcode s ; 
{/* 30 */ switch ( selector ) 
  {case 7 : 
    {
      putc ( xchr [ s ] ,  termout );
      putc ( xchr [ s ] ,  logfile );
      incr ( termoffset ) ; 
      incr ( fileoffset ) ; 
      if ( termoffset == maxprintline ) 
      {
	putc ('\n',  termout );
	termoffset = 0 ; 
      } 
      if ( fileoffset == maxprintline ) 
      {
	putc ('\n',  logfile );
	fileoffset = 0 ; 
      } 
    } 
    break ; 
  case 6 : 
    {
      putc ( xchr [ s ] ,  logfile );
      incr ( fileoffset ) ; 
      if ( fileoffset == maxprintline ) 
      println () ; 
    } 
    break ; 
  case 5 : 
    {
      putc ( xchr [ s ] ,  termout );
      incr ( termoffset ) ; 
      if ( termoffset == maxprintline ) 
      println () ; 
    } 
    break ; 
  case 8 : 
    {
      putc ( xchr [ s ] ,  psfile );
      incr ( psoffset ) ; 
    } 
    break ; 
  case 4 : 
    ; 
    break ; 
  case 9 : 
    if ( tally < trickcount ) 
    trickbuf [ tally % errorline ] = s ; 
    break ; 
  case 10 : 
    {
      if ( poolptr >= maxpoolptr ) 
      {
	unitstrroom () ; 
	if ( poolptr >= poolsize ) 
	goto lab30 ; 
      } 
      {
	strpool [ poolptr ] = s ; 
	incr ( poolptr ) ; 
      } 
    } 
    break ; 
    default: 
    putc ( xchr [ s ] ,  wrfile [ selector ] );
    break ; 
  } 
  lab30: incr ( tally ) ; 
} 
void zprint ( s ) 
integer s ; 
{poolpointer j  ; 
  if ( ( s < 0 ) || ( s > maxstrptr ) ) 
  s = 261 ; 
  j = strstart [ s ] ; 
  while ( j < strstart [ nextstr [ s ] ] ) {
      
    printchar ( strpool [ j ] ) ; 
    incr ( j ) ; 
  } 
} 
void zslowprint ( s ) 
integer s ; 
{poolpointer j  ; 
  if ( ( s < 0 ) || ( s >= maxstrptr ) ) 
  s = 261 ; 
  j = strstart [ s ] ; 
  while ( j < strstart [ nextstr [ s ] ] ) {
      
    print ( strpool [ j ] ) ; 
    incr ( j ) ; 
  } 
} 
void zprintnl ( s ) 
strnumber s ; 
{switch ( selector ) 
  {case 7 : 
    if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
    println () ; 
    break ; 
  case 6 : 
    if ( fileoffset > 0 ) 
    println () ; 
    break ; 
  case 5 : 
    if ( termoffset > 0 ) 
    println () ; 
    break ; 
  case 8 : 
    if ( psoffset > 0 ) 
    println () ; 
    break ; 
  case 4 : 
  case 9 : 
  case 10 : 
    ; 
    break ; 
  } 
  print ( s ) ; 
} 
void zprintthedigs ( k ) 
eightbits k ; 
{while ( k > 0 ) {
    
    decr ( k ) ; 
    printchar ( 48 + dig [ k ] ) ; 
  } 
} 
void zprintint ( n ) 
integer n ; 
{char k  ; 
  integer m  ; 
  k = 0 ; 
  if ( n < 0 ) 
  {
    printchar ( 45 ) ; 
    if ( n > -100000000L ) 
    n = - (integer) n ; 
    else {
	
      m = -1 - n ; 
      n = m / 10 ; 
      m = ( m % 10 ) + 1 ; 
      k = 1 ; 
      if ( m < 10 ) 
      dig [ 0 ] = m ; 
      else {
	  
	dig [ 0 ] = 0 ; 
	incr ( n ) ; 
      } 
    } 
  } 
  do {
      dig [ k ] = n % 10 ; 
    n = n / 10 ; 
    incr ( k ) ; 
  } while ( ! ( n == 0 ) ) ; 
  printthedigs ( k ) ; 
} 
void zprintscaled ( s ) 
scaled s ; 
{scaled delta  ; 
  if ( s < 0 ) 
  {
    printchar ( 45 ) ; 
    s = - (integer) s ; 
  } 
  printint ( s / 65536L ) ; 
  s = 10 * ( s % 65536L ) + 5 ; 
  if ( s != 5 ) 
  {
    delta = 10 ; 
    printchar ( 46 ) ; 
    do {
	if ( delta > 65536L ) 
      s = s + 32768L - ( delta / 2 ) ; 
      printchar ( 48 + ( s / 65536L ) ) ; 
      s = 10 * ( s % 65536L ) ; 
      delta = delta * 10 ; 
    } while ( ! ( s <= delta ) ) ; 
  } 
} 
void zprinttwo ( x , y ) 
scaled x ; 
scaled y ; 
{printchar ( 40 ) ; 
  printscaled ( x ) ; 
  printchar ( 44 ) ; 
  printscaled ( y ) ; 
  printchar ( 41 ) ; 
} 
void zprinttype ( t ) 
smallnumber t ; 
{switch ( t ) 
  {case 1 : 
    print ( 325 ) ; 
    break ; 
  case 2 : 
    print ( 326 ) ; 
    break ; 
  case 3 : 
    print ( 327 ) ; 
    break ; 
  case 4 : 
    print ( 260 ) ; 
    break ; 
  case 5 : 
    print ( 328 ) ; 
    break ; 
  case 6 : 
    print ( 329 ) ; 
    break ; 
  case 7 : 
    print ( 330 ) ; 
    break ; 
  case 8 : 
    print ( 331 ) ; 
    break ; 
  case 9 : 
    print ( 332 ) ; 
    break ; 
  case 10 : 
    print ( 333 ) ; 
    break ; 
  case 11 : 
    print ( 334 ) ; 
    break ; 
  case 12 : 
    print ( 335 ) ; 
    break ; 
  case 13 : 
    print ( 336 ) ; 
    break ; 
  case 14 : 
    print ( 337 ) ; 
    break ; 
  case 16 : 
    print ( 338 ) ; 
    break ; 
  case 17 : 
    print ( 339 ) ; 
    break ; 
  case 18 : 
    print ( 340 ) ; 
    break ; 
  case 15 : 
    print ( 341 ) ; 
    break ; 
  case 19 : 
    print ( 342 ) ; 
    break ; 
  case 20 : 
    print ( 343 ) ; 
    break ; 
  case 21 : 
    print ( 344 ) ; 
    break ; 
  case 22 : 
    print ( 345 ) ; 
    break ; 
  case 23 : 
    print ( 346 ) ; 
    break ; 
    default: 
    print ( 347 ) ; 
    break ; 
  } 
} 
integer trueline ( ) 
{register integer Result; integer k  ; 
  if ( ( curinput .indexfield <= 15 ) && ( curinput .namefield > 2 ) ) 
  Result = linestack [ curinput .indexfield ] ; 
  else {
      
    k = inputptr ; 
    while ( ( k > 0 ) && ( inputstack [ k ] .indexfield > 15 ) || ( inputstack 
    [ k ] .namefield <= 2 ) ) decr ( k ) ; 
    Result = linestack [ k ] ; 
  } 
  return(Result) ; 
} 
void begindiagnostic ( ) 
{oldsetting = selector ; 
  if ( selector == 8 ) 
  selector = nonpssetting ; 
  if ( ( internal [ 12 ] <= 0 ) && ( selector == 7 ) ) 
  {
    decr ( selector ) ; 
    if ( history == 0 ) 
    history = 1 ; 
  } 
} 
void zenddiagnostic ( blankline ) 
boolean blankline ; 
{printnl ( 285 ) ; 
  if ( blankline ) 
  println () ; 
  selector = oldsetting ; 
} 
void zprintdiagnostic ( s , t , nuline ) 
strnumber s ; 
strnumber t ; 
boolean nuline ; 
{begindiagnostic () ; 
  if ( nuline ) 
  printnl ( s ) ; 
  else print ( s ) ; 
  print ( 463 ) ; 
  printint ( trueline () ) ; 
  print ( t ) ; 
  printchar ( 58 ) ; 
} 
void zprintfilename ( n , a , e ) 
integer n ; 
integer a ; 
integer e ; 
{print ( a ) ; 
  print ( n ) ; 
  print ( e ) ; 
} 
#ifdef DEBUG
#endif /* DEBUG */
void zflushstring ( s ) 
strnumber s ; 
{
	;
#ifdef STAT
  poolinuse = poolinuse - ( strstart [ nextstr [ s ] ] - strstart [ s ] ) ; 
  decr ( strsinuse ) ; 
#endif /* STAT */
  if ( nextstr [ s ] != strptr ) 
  strref [ s ] = 0 ; 
  else {
      
    strptr = s ; 
    decr ( strsusedup ) ; 
  } 
  poolptr = strstart [ strptr ] ; 
} 
void jumpout ( ) 
{closefilesandterminate () ; 
  readyalready = 0 ; 
  if ( ( history != 0 ) && ( history != 1 ) ) 
  uexit ( 1 ) ; 
  else uexit ( 0 ) ; 
} 
void error ( ) 
{/* 22 10 */ ASCIIcode c  ; 
  integer s1, s2, s3  ; 
  poolpointer j  ; 
  if ( history < 2 ) 
  history = 2 ; 
  printchar ( 46 ) ; 
  showcontext () ; 
  if ( interaction == 3 ) 
  while ( true ) {
      
    lab22: clearforerrorprompt () ; 
    {
      ; 
      print ( 265 ) ; 
      terminput () ; 
    } 
    if ( last == first ) 
    goto lab10 ; 
    c = buffer [ first ] ; 
    if ( c >= 97 ) 
    c = c - 32 ; 
    switch ( c ) 
    {case 48 : 
    case 49 : 
    case 50 : 
    case 51 : 
    case 52 : 
    case 53 : 
    case 54 : 
    case 55 : 
    case 56 : 
    case 57 : 
      if ( deletionsallowed ) 
      {
	s1 = curcmd ; 
	s2 = curmod ; 
	s3 = cursym ; 
	OKtointerrupt = false ; 
	if ( ( last > first + 1 ) && ( buffer [ first + 1 ] >= 48 ) && ( 
	buffer [ first + 1 ] <= 57 ) ) 
	c = c * 10 + buffer [ first + 1 ] - 48 * 11 ; 
	else c = c - 48 ; 
	while ( c > 0 ) {
	    
	  getnext () ; 
	  if ( curcmd == 41 ) 
	  {
	    if ( strref [ curmod ] < 127 ) 
	    if ( strref [ curmod ] > 1 ) 
	    decr ( strref [ curmod ] ) ; 
	    else flushstring ( curmod ) ; 
	  } 
	  decr ( c ) ; 
	} 
	curcmd = s1 ; 
	curmod = s2 ; 
	cursym = s3 ; 
	OKtointerrupt = true ; 
	{
	  helpptr = 2 ; 
	  helpline [ 1 ] = 278 ; 
	  helpline [ 0 ] = 279 ; 
	} 
	showcontext () ; 
	goto lab22 ; 
      } 
      break ; 
	;
#ifdef DEBUG
    case 68 : 
      {
	debughelp () ; 
	goto lab22 ; 
      } 
      break ; 
#endif /* DEBUG */
    case 69 : 
      if ( fileptr > 0 ) 
      {
	editnamestart = strstart [ inputstack [ fileptr ] .namefield ] ; 
	editnamelength = ( strstart [ nextstr [ inputstack [ fileptr ] .namefield ] ] - strstart [ inputstack [ fileptr ] .namefield ] ) ; 
	editline = trueline () ; 
	jumpout () ; 
      } 
      break ; 
    case 72 : 
      {
	if ( useerrhelp ) 
	{
	  j = strstart [ errhelp ] ; 
	  while ( j < strstart [ nextstr [ errhelp ] ] ) {
	      
	    if ( strpool [ j ] != 37 ) 
	    print ( strpool [ j ] ) ; 
	    else if ( j + 1 == strstart [ nextstr [ errhelp ] ] ) 
	    println () ; 
	    else if ( strpool [ j + 1 ] != 37 ) 
	    println () ; 
	    else {
		
	      incr ( j ) ; 
	      printchar ( 37 ) ; 
	    } 
	    incr ( j ) ; 
	  } 
	  useerrhelp = false ; 
	} 
	else {
	    
	  if ( helpptr == 0 ) 
	  {
	    helpptr = 2 ; 
	    helpline [ 1 ] = 280 ; 
	    helpline [ 0 ] = 281 ; 
	  } 
	  do {
	      decr ( helpptr ) ; 
	    print ( helpline [ helpptr ] ) ; 
	    println () ; 
	  } while ( ! ( helpptr == 0 ) ) ; 
	} 
	{
	  helpptr = 4 ; 
	  helpline [ 3 ] = 282 ; 
	  helpline [ 2 ] = 281 ; 
	  helpline [ 1 ] = 283 ; 
	  helpline [ 0 ] = 284 ; 
	} 
	goto lab22 ; 
      } 
      break ; 
    case 73 : 
      {
	beginfilereading () ; 
	if ( last > first + 1 ) 
	{
	  curinput .locfield = first + 1 ; 
	  buffer [ first ] = 32 ; 
	} 
	else {
	    
	  {
	    ; 
	    print ( 277 ) ; 
	    terminput () ; 
	  } 
	  curinput .locfield = first ; 
	} 
	first = last + 1 ; 
	curinput .limitfield = last ; 
	goto lab10 ; 
      } 
      break ; 
    case 81 : 
    case 82 : 
    case 83 : 
      {
	errorcount = 0 ; 
	interaction = 0 + c - 81 ; 
	print ( 272 ) ; 
	switch ( c ) 
	{case 81 : 
	  {
	    print ( 273 ) ; 
	    decr ( selector ) ; 
	  } 
	  break ; 
	case 82 : 
	  print ( 274 ) ; 
	  break ; 
	case 83 : 
	  print ( 275 ) ; 
	  break ; 
	} 
	print ( 276 ) ; 
	println () ; 
	flush ( termout ) ; 
	goto lab10 ; 
      } 
      break ; 
    case 88 : 
      {
	interaction = 2 ; 
	jumpout () ; 
      } 
      break ; 
      default: 
      ; 
      break ; 
    } 
    {
      print ( 266 ) ; 
      printnl ( 267 ) ; 
      printnl ( 268 ) ; 
      if ( fileptr > 0 ) 
      print ( 269 ) ; 
      if ( deletionsallowed ) 
      printnl ( 270 ) ; 
      printnl ( 271 ) ; 
    } 
  } 
  incr ( errorcount ) ; 
  if ( errorcount == 100 ) 
  {
    printnl ( 264 ) ; 
    history = 3 ; 
    jumpout () ; 
  } 
  if ( interaction > 0 ) 
  decr ( selector ) ; 
  if ( useerrhelp ) 
  {
    printnl ( 285 ) ; 
    j = strstart [ errhelp ] ; 
    while ( j < strstart [ nextstr [ errhelp ] ] ) {
	
      if ( strpool [ j ] != 37 ) 
      print ( strpool [ j ] ) ; 
      else if ( j + 1 == strstart [ nextstr [ errhelp ] ] ) 
      println () ; 
      else if ( strpool [ j + 1 ] != 37 ) 
      println () ; 
      else {
	  
	incr ( j ) ; 
	printchar ( 37 ) ; 
      } 
      incr ( j ) ; 
    } 
  } 
  else while ( helpptr > 0 ) {
      
    decr ( helpptr ) ; 
    printnl ( helpline [ helpptr ] ) ; 
  } 
  println () ; 
  if ( interaction > 0 ) 
  incr ( selector ) ; 
  println () ; 
  lab10: ; 
} 
void zfatalerror ( s ) 
strnumber s ; 
{normalizeselector () ; 
  {
    if ( interaction == 3 ) 
    ; 
    printnl ( 263 ) ; 
    print ( 286 ) ; 
  } 
  {
    helpptr = 1 ; 
    helpline [ 0 ] = s ; 
  } 
  {
    if ( interaction == 3 ) 
    interaction = 2 ; 
    if ( logopened ) 
    error () ; 
	;
#ifdef DEBUG
    if ( interaction > 0 ) 
    debughelp () ; 
#endif /* DEBUG */
    history = 3 ; 
    jumpout () ; 
  } 
} 
void zoverflow ( s , n ) 
strnumber s ; 
integer n ; 
{normalizeselector () ; 
  {
    if ( interaction == 3 ) 
    ; 
    printnl ( 263 ) ; 
    print ( 287 ) ; 
  } 
  print ( s ) ; 
  printchar ( 61 ) ; 
  printint ( n ) ; 
  printchar ( 93 ) ; 
  {
    helpptr = 2 ; 
    helpline [ 1 ] = 288 ; 
    helpline [ 0 ] = 289 ; 
  } 
  {
    if ( interaction == 3 ) 
    interaction = 2 ; 
    if ( logopened ) 
    error () ; 
	;
#ifdef DEBUG
    if ( interaction > 0 ) 
    debughelp () ; 
#endif /* DEBUG */
    history = 3 ; 
    jumpout () ; 
  } 
} 
void zconfusion ( s ) 
strnumber s ; 
{normalizeselector () ; 
  if ( history < 2 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 290 ) ; 
    } 
    print ( s ) ; 
    printchar ( 41 ) ; 
    {
      helpptr = 1 ; 
      helpline [ 0 ] = 291 ; 
    } 
  } 
  else {
      
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 292 ) ; 
    } 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 293 ; 
      helpline [ 0 ] = 294 ; 
    } 
  } 
  {
    if ( interaction == 3 ) 
    interaction = 2 ; 
    if ( logopened ) 
    error () ; 
	;
#ifdef DEBUG
    if ( interaction > 0 ) 
    debughelp () ; 
#endif /* DEBUG */
    history = 3 ; 
    jumpout () ; 
  } 
} 
void zdocompaction ( needed ) 
poolpointer needed ; 
{/* 30 */ strnumber struse  ; 
  strnumber r, s, t  ; 
  poolpointer p, q  ; 
  t = nextstr [ lastfixedstr ] ; 
  while ( ( strref [ t ] == 127 ) && ( t != strptr ) ) {
      
    incr ( fixedstruse ) ; 
    lastfixedstr = t ; 
    t = nextstr [ t ] ; 
  } 
  struse = fixedstruse ; 
  r = lastfixedstr ; 
  s = nextstr [ r ] ; 
  p = strstart [ s ] ; 
  while ( s != strptr ) {
      
    while ( strref [ s ] == 0 ) {
	
      t = s ; 
      s = nextstr [ s ] ; 
      nextstr [ r ] = s ; 
      nextstr [ t ] = nextstr [ strptr ] ; 
      nextstr [ strptr ] = t ; 
      if ( s == strptr ) 
      goto lab30 ; 
    } 
    r = s ; 
    s = nextstr [ s ] ; 
    incr ( struse ) ; 
    q = strstart [ r ] ; 
    strstart [ r ] = p ; 
    while ( q < strstart [ s ] ) {
	
      strpool [ p ] = strpool [ q ] ; 
      incr ( p ) ; 
      incr ( q ) ; 
    } 
  } 
  lab30: q = strstart [ strptr ] ; 
  strstart [ strptr ] = p ; 
  while ( q < poolptr ) {
      
    strpool [ p ] = strpool [ q ] ; 
    incr ( p ) ; 
    incr ( q ) ; 
  } 
  poolptr = p ; 
  if ( needed >= 0 ) 
  {
    if ( struse >= maxstrings - 1 ) 
    {
      stroverflowed = true ; 
      overflow ( 258 , maxstrings - 1 - initstruse ) ; 
    } 
    if ( poolptr + needed > maxpoolptr ) 
    if ( poolptr + needed > poolsize ) 
    {
      stroverflowed = true ; 
      overflow ( 259 , poolsize - initpoolptr ) ; 
    } 
    else maxpoolptr = poolptr + needed ; 
  } 
	;
#ifdef STAT
  if ( ( strstart [ strptr ] != poolinuse ) || ( struse != strsinuse ) ) 
  confusion ( 260 ) ; 
  incr ( pactcount ) ; 
  pactchars = pactchars + poolptr - strstart [ nextstr [ lastfixedstr ] ] ; 
  pactstrs = pactstrs + struse - fixedstruse ; 
	;
#ifdef DEBUG
  s = strptr ; 
  t = struse ; 
  while ( s <= maxstrptr ) {
      
    if ( t > maxstrptr ) 
    confusion ( 34 ) ; 
    incr ( t ) ; 
    s = nextstr [ s ] ; 
  } 
  if ( t <= maxstrptr ) 
  confusion ( 34 ) ; 
#endif /* DEBUG */
#endif /* STAT */
  strsusedup = struse ; 
} 
void unitstrroom ( ) 
{if ( poolptr >= poolsize ) 
  docompaction ( -1 ) ; 
  if ( poolptr >= maxpoolptr ) 
  maxpoolptr = poolptr + 1 ; 
} 
strnumber makestring ( ) 
{/* 20 */ register strnumber Result; strnumber s  ; 
  lab20: s = strptr ; 
  strptr = nextstr [ s ] ; 
  if ( strptr > maxstrptr ) 
  if ( strptr == maxstrings ) 
  {
    strptr = s ; 
    docompaction ( 0 ) ; 
    goto lab20 ; 
  } 
  else {
      
    maxstrptr = strptr ; 
    nextstr [ strptr ] = maxstrptr + 1 ; 
  } 
  strref [ s ] = 1 ; 
  strstart [ strptr ] = poolptr ; 
  incr ( strsusedup ) ; 
	;
#ifdef DEBUG
  if ( strptr == maxstrptr ) 
  if ( strsusedup != strptr ) 
  confusion ( 115 ) ; 
#endif /* DEBUG */
	;
#ifdef STAT
  incr ( strsinuse ) ; 
  poolinuse = poolinuse + ( strstart [ nextstr [ s ] ] - strstart [ s ] ) ; 
  if ( poolinuse > maxplused ) 
  maxplused = poolinuse ; 
  if ( strsinuse > maxstrsused ) 
  maxstrsused = strsinuse ; 
#endif /* STAT */
  Result = s ; 
  return(Result) ; 
} 
void zchoplaststring ( p ) 
poolpointer p ; 
{
	;
#ifdef STAT
  poolinuse = poolinuse + ( p - strstart [ strptr ] ) ; 
#endif /* STAT */
  strstart [ strptr ] = p ; 
} 
boolean zstreqbuf ( s , k ) 
strnumber s ; 
integer k ; 
{/* 45 */ register boolean Result; poolpointer j  ; 
  boolean result  ; 
  j = strstart [ s ] ; 
  while ( j < strstart [ nextstr [ s ] ] ) {
      
    if ( strpool [ j ] != buffer [ k ] ) 
    {
      result = false ; 
      goto lab45 ; 
    } 
    incr ( j ) ; 
    incr ( k ) ; 
  } 
  result = true ; 
  lab45: Result = result ; 
  return(Result) ; 
} 
integer zstrvsstr ( s , t ) 
strnumber s ; 
strnumber t ; 
{/* 10 */ register integer Result; poolpointer j, k  ; 
  integer ls, lt  ; 
  integer l  ; 
  ls = ( strstart [ nextstr [ s ] ] - strstart [ s ] ) ; 
  lt = ( strstart [ nextstr [ t ] ] - strstart [ t ] ) ; 
  if ( ls <= lt ) 
  l = ls ; 
  else l = lt ; 
  j = strstart [ s ] ; 
  k = strstart [ t ] ; 
  while ( l > 0 ) {
      
    if ( strpool [ j ] != strpool [ k ] ) 
    {
      Result = strpool [ j ] - strpool [ k ] ; 
      goto lab10 ; 
    } 
    incr ( j ) ; 
    incr ( k ) ; 
    decr ( l ) ; 
  } 
  Result = ls - lt ; 
  lab10: ; 
  return(Result) ; 
} 
void zprintdd ( n ) 
integer n ; 
{n = abs ( n ) % 100 ; 
  printchar ( 48 + ( n / 10 ) ) ; 
  printchar ( 48 + ( n % 10 ) ) ; 
} 
void terminput ( ) 
{integer k  ; 
  flush ( termout ) ; 
  if ( ! inputln ( termin , true ) ) 
  fatalerror ( 262 ) ; 
  termoffset = 0 ; 
  decr ( selector ) ; 
  if ( last != first ) 
  {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
  for_end) do 
    print ( buffer [ k ] ) ; 
  while ( k++ < for_end ) ; } 
  println () ; 
  buffer [ last ] = 37 ; 
  incr ( selector ) ; 
} 
void normalizeselector ( ) 
{if ( logopened ) 
  selector = 7 ; 
  else selector = 5 ; 
  if ( jobname == 0 ) 
  openlogfile () ; 
  if ( interaction == 0 ) 
  decr ( selector ) ; 
} 
void pauseforinstructions ( ) 
{if ( OKtointerrupt ) 
  {
    interaction = 3 ; 
    if ( ( selector == 6 ) || ( selector == 4 ) ) 
    incr ( selector ) ; 
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 295 ) ; 
    } 
    {
      helpptr = 3 ; 
      helpline [ 2 ] = 296 ; 
      helpline [ 1 ] = 297 ; 
      helpline [ 0 ] = 298 ; 
    } 
    deletionsallowed = false ; 
    error () ; 
    deletionsallowed = true ; 
    interrupt = 0 ; 
  } 
} 
void zmissingerr ( s ) 
strnumber s ; 
{{
    
    if ( interaction == 3 ) 
    ; 
    printnl ( 263 ) ; 
    print ( 299 ) ; 
  } 
  print ( s ) ; 
  print ( 300 ) ; 
} 
void cleararith ( ) 
{{
    
    if ( interaction == 3 ) 
    ; 
    printnl ( 263 ) ; 
    print ( 301 ) ; 
  } 
  {
    helpptr = 4 ; 
    helpline [ 3 ] = 302 ; 
    helpline [ 2 ] = 303 ; 
    helpline [ 1 ] = 304 ; 
    helpline [ 0 ] = 305 ; 
  } 
  error () ; 
  aritherror = false ; 
} 
integer zslowadd ( x , y ) 
integer x ; 
integer y ; 
{register integer Result; if ( x >= 0 ) 
  if ( y <= 2147483647L - x ) 
  Result = x + y ; 
  else {
      
    aritherror = true ; 
    Result = 2147483647L ; 
  } 
  else if ( - (integer) y <= 2147483647L + x ) 
  Result = x + y ; 
  else {
      
    aritherror = true ; 
    Result = -2147483647L ; 
  } 
  return(Result) ; 
} 
scaled zrounddecimals ( k ) 
smallnumber k ; 
{register scaled Result; integer a  ; 
  a = 0 ; 
  while ( k > 0 ) {
      
    decr ( k ) ; 
    a = ( a + dig [ k ] * 131072L ) / 10 ; 
  } 
  Result = halfp ( a + 1 ) ; 
  return(Result) ; 
} 
#ifdef FIXPT
fraction zmakefraction ( p , q ) 
integer p ; 
integer q ; 
{register fraction Result; integer f  ; 
  integer n  ; 
  boolean negative  ; 
  integer becareful  ; 
  if ( p >= 0 ) 
  negative = false ; 
  else {
      
    p = - (integer) p ; 
    negative = true ; 
  } 
  if ( q <= 0 ) 
  {
	;
#ifdef DEBUG
    if ( q == 0 ) 
    confusion ( 47 ) ; 
#endif /* DEBUG */
    q = - (integer) q ; 
    negative = ! negative ; 
  } 
  n = p / q ; 
  p = p % q ; 
  if ( n >= 8 ) 
  {
    aritherror = true ; 
    if ( negative ) 
    Result = -2147483647L ; 
    else Result = 2147483647L ; 
  } 
  else {
      
    n = ( n - 1 ) * 268435456L ; 
    f = 1 ; 
    do {
	becareful = p - q ; 
      p = becareful + p ; 
      if ( p >= 0 ) 
      f = f + f + 1 ; 
      else {
	  
	f = f + f ; 
	p = p + q ; 
      } 
    } while ( ! ( f >= 268435456L ) ) ; 
    becareful = p - q ; 
    if ( becareful + p >= 0 ) 
    incr ( f ) ; 
    if ( negative ) 
    Result = - (integer) ( f + n ) ; 
    else Result = f + n ; 
  } 
  return(Result) ; 
} 
#endif /* FIXPT */
#ifdef FIXPT
integer ztakefraction ( q , f ) 
integer q ; 
fraction f ; 
{register integer Result; integer p  ; 
  boolean negative  ; 
  integer n  ; 
  integer becareful  ; 
  if ( f >= 0 ) 
  negative = false ; 
  else {
      
    f = - (integer) f ; 
    negative = true ; 
  } 
  if ( q < 0 ) 
  {
    q = - (integer) q ; 
    negative = ! negative ; 
  } 
  if ( f < 268435456L ) 
  n = 0 ; 
  else {
      
    n = f / 268435456L ; 
    f = f % 268435456L ; 
    if ( q <= 2147483647L / n ) 
    n = n * q ; 
    else {
	
      aritherror = true ; 
      n = 2147483647L ; 
    } 
  } 
  f = f + 268435456L ; 
  p = 134217728L ; 
  if ( q < 1073741824L ) 
  do {
      if ( odd ( f ) ) 
    p = halfp ( p + q ) ; 
    else p = halfp ( p ) ; 
    f = halfp ( f ) ; 
  } while ( ! ( f == 1 ) ) ; 
  else do {
      if ( odd ( f ) ) 
    p = p + halfp ( q - p ) ; 
    else p = halfp ( p ) ; 
    f = halfp ( f ) ; 
  } while ( ! ( f == 1 ) ) ; 
  becareful = n - 2147483647L ; 
  if ( becareful + p > 0 ) 
  {
    aritherror = true ; 
    n = 2147483647L - p ; 
  } 
  if ( negative ) 
  Result = - (integer) ( n + p ) ; 
  else Result = n + p ; 
  return(Result) ; 
} 
#endif /* FIXPT */
#ifdef FIXPT
integer ztakescaled ( q , f ) 
integer q ; 
scaled f ; 
{register integer Result; integer p  ; 
  boolean negative  ; 
  integer n  ; 
  integer becareful  ; 
  if ( f >= 0 ) 
  negative = false ; 
  else {
      
    f = - (integer) f ; 
    negative = true ; 
  } 
  if ( q < 0 ) 
  {
    q = - (integer) q ; 
    negative = ! negative ; 
  } 
  if ( f < 65536L ) 
  n = 0 ; 
  else {
      
    n = f / 65536L ; 
    f = f % 65536L ; 
    if ( q <= 2147483647L / n ) 
    n = n * q ; 
    else {
	
      aritherror = true ; 
      n = 2147483647L ; 
    } 
  } 
  f = f + 65536L ; 
  p = 32768L ; 
  if ( q < 1073741824L ) 
  do {
      if ( odd ( f ) ) 
    p = halfp ( p + q ) ; 
    else p = halfp ( p ) ; 
    f = halfp ( f ) ; 
  } while ( ! ( f == 1 ) ) ; 
  else do {
      if ( odd ( f ) ) 
    p = p + halfp ( q - p ) ; 
    else p = halfp ( p ) ; 
    f = halfp ( f ) ; 
  } while ( ! ( f == 1 ) ) ; 
  becareful = n - 2147483647L ; 
  if ( becareful + p > 0 ) 
  {
    aritherror = true ; 
    n = 2147483647L - p ; 
  } 
  if ( negative ) 
  Result = - (integer) ( n + p ) ; 
  else Result = n + p ; 
  return(Result) ; 
} 
#endif /* FIXPT */
#ifdef FIXPT
scaled zmakescaled ( p , q ) 
integer p ; 
integer q ; 
{register scaled Result; integer f  ; 
  integer n  ; 
  boolean negative  ; 
  integer becareful  ; 
  if ( p >= 0 ) 
  negative = false ; 
  else {
      
    p = - (integer) p ; 
    negative = true ; 
  } 
  if ( q <= 0 ) 
  {
	;
#ifdef DEBUG
    if ( q == 0 ) 
    confusion ( 47 ) ; 
#endif /* DEBUG */
    q = - (integer) q ; 
    negative = ! negative ; 
  } 
  n = p / q ; 
  p = p % q ; 
  if ( n >= 32768L ) 
  {
    aritherror = true ; 
    if ( negative ) 
    Result = -2147483647L ; 
    else Result = 2147483647L ; 
  } 
  else {
      
    n = ( n - 1 ) * 65536L ; 
    f = 1 ; 
    do {
	becareful = p - q ; 
      p = becareful + p ; 
      if ( p >= 0 ) 
      f = f + f + 1 ; 
      else {
	  
	f = f + f ; 
	p = p + q ; 
      } 
    } while ( ! ( f >= 65536L ) ) ; 
    becareful = p - q ; 
    if ( becareful + p >= 0 ) 
    incr ( f ) ; 
    if ( negative ) 
    Result = - (integer) ( f + n ) ; 
    else Result = f + n ; 
  } 
  return(Result) ; 
} 
#endif /* FIXPT */
fraction zvelocity ( st , ct , sf , cf , t ) 
fraction st ; 
fraction ct ; 
fraction sf ; 
fraction cf ; 
scaled t ; 
{register fraction Result; integer acc, num, denom  ; 
  acc = takefraction ( st - ( sf / 16 ) , sf - ( st / 16 ) ) ; 
  acc = takefraction ( acc , ct - cf ) ; 
  num = 536870912L + takefraction ( acc , 379625062L ) ; 
  denom = 805306368L + takefraction ( ct , 497706707L ) + takefraction ( cf ,  307599661L ) ; 
  if ( t != 65536L ) 
  num = makescaled ( num , t ) ; 
  if ( num / 4 >= denom ) 
  Result = 1073741824L ; 
  else Result = makefraction ( num , denom ) ; 
  return(Result) ; 
} 
integer zabvscd ( a , b , c , d ) 
integer a ; 
integer b ; 
integer c ; 
integer d ; 
{/* 10 */ register integer Result; integer q, r  ; 
  if ( a < 0 ) 
  {
    a = - (integer) a ; 
    b = - (integer) b ; 
  } 
  if ( c < 0 ) 
  {
    c = - (integer) c ; 
    d = - (integer) d ; 
  } 
  if ( d <= 0 ) 
  {
    if ( b >= 0 ) 
    if ( ( ( a == 0 ) || ( b == 0 ) ) && ( ( c == 0 ) || ( d == 0 ) ) ) 
    {
      Result = 0 ; 
      goto lab10 ; 
    } 
    else {
	
      Result = 1 ; 
      goto lab10 ; 
    } 
    if ( d == 0 ) 
    if ( a == 0 ) 
    {
      Result = 0 ; 
      goto lab10 ; 
    } 
    else {
	
      Result = -1 ; 
      goto lab10 ; 
    } 
    q = a ; 
    a = c ; 
    c = q ; 
    q = - (integer) b ; 
    b = - (integer) d ; 
    d = q ; 
  } 
  else if ( b <= 0 ) 
  {
    if ( b < 0 ) 
    if ( a > 0 ) 
    {
      Result = -1 ; 
      goto lab10 ; 
    } 
    if ( c == 0 ) 
    {
      Result = 0 ; 
      goto lab10 ; 
    } 
    else {
	
      Result = -1 ; 
      goto lab10 ; 
    } 
  } 
  while ( true ) {
      
    q = a / d ; 
    r = c / b ; 
    if ( q != r ) 
    if ( q > r ) 
    {
      Result = 1 ; 
      goto lab10 ; 
    } 
    else {
	
      Result = -1 ; 
      goto lab10 ; 
    } 
    q = a % d ; 
    r = c % b ; 
    if ( r == 0 ) 
    if ( q == 0 ) 
    {
      Result = 0 ; 
      goto lab10 ; 
    } 
    else {
	
      Result = 1 ; 
      goto lab10 ; 
    } 
    if ( q == 0 ) 
    {
      Result = -1 ; 
      goto lab10 ; 
    } 
    a = b ; 
    b = q ; 
    c = d ; 
    d = r ; 
  } 
  lab10: ; 
  return(Result) ; 
} 
scaled zfloorscaled ( x ) 
scaled x ; 
{register scaled Result; integer becareful  ; 
  if ( x >= 0 ) 
  Result = x - ( x % 65536L ) ; 
  else {
      
    becareful = x + 1 ; 
    Result = x + ( ( - (integer) becareful ) % 65536L ) - 65535L ; 
  } 
  return(Result) ; 
} 
integer zroundunscaled ( x ) 
scaled x ; 
{register integer Result; integer becareful  ; 
  if ( x >= 32768L ) 
  Result = 1 + ( ( x - 32768L ) / 65536L ) ; 
  else if ( x >= -32768L ) 
  Result = 0 ; 
  else {
      
    becareful = x + 1 ; 
    Result = - (integer) ( 1 + ( ( - (integer) becareful - 32768L ) / 65536L ) 
    ) ; 
  } 
  return(Result) ; 
} 
scaled zroundfraction ( x ) 
fraction x ; 
{register scaled Result; integer becareful  ; 
  if ( x >= 2048 ) 
  Result = 1 + ( ( x - 2048 ) / 4096 ) ; 
  else if ( x >= -2048 ) 
  Result = 0 ; 
  else {
      
    becareful = x + 1 ; 
    Result = - (integer) ( 1 + ( ( - (integer) becareful - 2048 ) / 4096 ) ) ; 
  } 
  return(Result) ; 
} 
scaled zsquarert ( x ) 
scaled x ; 
{register scaled Result; smallnumber k  ; 
  integer y, q  ; 
  if ( x <= 0 ) 
  {
    if ( x < 0 ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 306 ) ; 
      } 
      printscaled ( x ) ; 
      print ( 307 ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 308 ; 
	helpline [ 0 ] = 309 ; 
      } 
      error () ; 
    } 
    Result = 0 ; 
  } 
  else {
      
    k = 23 ; 
    q = 2 ; 
    while ( x < 536870912L ) {
	
      decr ( k ) ; 
      x = x + x + x + x ; 
    } 
    if ( x < 1073741824L ) 
    y = 0 ; 
    else {
	
      x = x - 1073741824L ; 
      y = 1 ; 
    } 
    do {
	x = x + x ; 
      y = y + y ; 
      if ( x >= 1073741824L ) 
      {
	x = x - 1073741824L ; 
	incr ( y ) ; 
      } 
      x = x + x ; 
      y = y + y - q ; 
      q = q + q ; 
      if ( x >= 1073741824L ) 
      {
	x = x - 1073741824L ; 
	incr ( y ) ; 
      } 
      if ( y > q ) 
      {
	y = y - q ; 
	q = q + 2 ; 
      } 
      else if ( y <= 0 ) 
      {
	q = q - 2 ; 
	y = y + q ; 
      } 
      decr ( k ) ; 
    } while ( ! ( k == 0 ) ) ; 
    Result = halfp ( q ) ; 
  } 
  return(Result) ; 
} 
integer zpythadd ( a , b ) 
integer a ; 
integer b ; 
{/* 30 */ register integer Result; fraction r  ; 
  boolean big  ; 
  a = abs ( a ) ; 
  b = abs ( b ) ; 
  if ( a < b ) 
  {
    r = b ; 
    b = a ; 
    a = r ; 
  } 
  if ( b > 0 ) 
  {
    if ( a < 536870912L ) 
    big = false ; 
    else {
	
      a = a / 4 ; 
      b = b / 4 ; 
      big = true ; 
    } 
    while ( true ) {
	
      r = makefraction ( b , a ) ; 
      r = takefraction ( r , r ) ; 
      if ( r == 0 ) 
      goto lab30 ; 
      r = makefraction ( r , 1073741824L + r ) ; 
      a = a + takefraction ( a + a , r ) ; 
      b = takefraction ( b , r ) ; 
    } 
    lab30: ; 
    if ( big ) 
    if ( a < 536870912L ) 
    a = a + a + a + a ; 
    else {
	
      aritherror = true ; 
      a = 2147483647L ; 
    } 
  } 
  Result = a ; 
  return(Result) ; 
} 
integer zpythsub ( a , b ) 
integer a ; 
integer b ; 
{/* 30 */ register integer Result; fraction r  ; 
  boolean big  ; 
  a = abs ( a ) ; 
  b = abs ( b ) ; 
  if ( a <= b ) 
  {
    if ( a < b ) 
    {
      {
	if ( interaction == 3 ) 
	; 
	printnl ( 263 ) ; 
	print ( 310 ) ; 
      } 
      printscaled ( a ) ; 
      print ( 311 ) ; 
      printscaled ( b ) ; 
      print ( 307 ) ; 
      {
	helpptr = 2 ; 
	helpline [ 1 ] = 308 ; 
	helpline [ 0 ] = 309 ; 
      } 
      error () ; 
    } 
    a = 0 ; 
  } 
  else {
      
    if ( a < 1073741824L ) 
    big = false ; 
    else {
	
      a = halfp ( a ) ; 
      b = halfp ( b ) ; 
      big = true ; 
    } 
    while ( true ) {
	
      r = makefraction ( b , a ) ; 
      r = takefraction ( r , r ) ; 
      if ( r == 0 ) 
      goto lab30 ; 
      r = makefraction ( r , 1073741824L - r ) ; 
      a = a - takefraction ( a + a , r ) ; 
      b = takefraction ( b , r ) ; 
    } 
    lab30: ; 
    if ( big ) 
    a = a + a ; 
  } 
  Result = a ; 
  return(Result) ; 
} 
scaled zmlog ( x ) 
scaled x ; 
{register scaled Result; integer y, z  ; 
  integer k  ; 
  if ( x <= 0 ) 
  {
    {
      if ( interaction == 3 ) 
      ; 
      printnl ( 263 ) ; 
      print ( 312 ) ; 
    } 
    printscaled ( x ) ; 
    print ( 307 ) ; 
    {
      helpptr = 2 ; 
      helpline [ 1 ] = 313 ; 
      helpline [ 0 ] = 309 ; 
    } 
    error () ; 
    Result = 0 ; 
  } 
  else {
      
    y = 1302456860L ; 
    z = 6581195L ; 
    while ( x < 1073741824L ) {
	
      x = x + x ; 
      y = y - 93032639L ; 
      z = z - 48782L ; 
    } 
    y = y + ( z / 65536L ) ; 
    k = 2 ; 
    while ( x > 1073741828L ) {
	
      z = ( ( x - 1 ) / twotothe [ k ] ) + 1 ; 
      while ( x < 1073741824L + z ) {
	  
	z = halfp ( z + 1 ) ; 
	k = k + 1 ; 
      } 
      y = y + speclog [ k ] ; 
      x = x - z ; 
    } 
    Result = y / 8 ; 
  } 
  return(Result) ; 
}